From 8e3426c5fcde28b01433011824f537e7cd966dc0 Mon Sep 17 00:00:00 2001 From: beegiik Date: Thu, 14 Aug 2025 10:15:47 +0100 Subject: [PATCH 1/9] feat(standalone): Create standalone daemon for non-k8s orchestration and add additional unit tests --- cmd/bootstrap_manager.go | 84 +++++++++ cmd/root.go | 7 +- cmd/standalone/daemon.go | 69 ++++++++ cmd/standard/daemon.go | 108 ++++-------- cmd/telemetry/telemetry.go | 48 +++++ go.mod | 2 +- pkg/config/config.go | 2 + pkg/controllers/cache/standalone_cache.go | 95 ++++++++++ .../cache/standalone_cache_test.go | 164 ++++++++++++++++++ pkg/enricher/ctrinfo/helper.go | 83 +++++++++ pkg/enricher/ctrinfo/helper_test.go | 116 +++++++++++++ pkg/enricher/ctrinfo/mock_podSpec.json | 99 +++++++++++ pkg/enricher/standalone.go | 151 ++++++++++++++++ pkg/enricher/standalone_test.go | 156 +++++++++++++++++ pkg/enricher/{enricher.go => standard.go} | 0 .../{enricher_test.go => standard_test.go} | 0 pkg/enricher/statefile/helper.go | 75 ++++++++ pkg/enricher/statefile/helper_test.go | 103 +++++++++++ pkg/enricher/statefile/mock_statefile.json | 37 ++++ pkg/metrics/metrics.go | 8 +- pkg/metrics/types.go | 8 +- pkg/plugin/hnsstats/hnsstats_windows.go | 108 ++++++++++-- pkg/plugin/hnsstats/types_windows.go | 100 ++++++++++- 23 files changed, 1518 insertions(+), 105 deletions(-) create mode 100644 cmd/bootstrap_manager.go create mode 100644 cmd/standalone/daemon.go create mode 100644 cmd/telemetry/telemetry.go create mode 100644 pkg/controllers/cache/standalone_cache.go create mode 100644 pkg/controllers/cache/standalone_cache_test.go create mode 100644 pkg/enricher/ctrinfo/helper.go create mode 100644 pkg/enricher/ctrinfo/helper_test.go create mode 100644 pkg/enricher/ctrinfo/mock_podSpec.json create mode 100644 pkg/enricher/standalone.go create mode 100644 pkg/enricher/standalone_test.go rename pkg/enricher/{enricher.go => standard.go} (100%) rename pkg/enricher/{enricher_test.go => standard_test.go} (100%) create mode 100644 pkg/enricher/statefile/helper.go create mode 100644 pkg/enricher/statefile/helper_test.go create mode 100644 pkg/enricher/statefile/mock_statefile.json diff --git a/cmd/bootstrap_manager.go b/cmd/bootstrap_manager.go new file mode 100644 index 0000000000..2eb61caa4c --- /dev/null +++ b/cmd/bootstrap_manager.go @@ -0,0 +1,84 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package cmd + +import ( + "fmt" + "strings" + + "github.com/microsoft/retina/cmd/standalone" + "github.com/microsoft/retina/cmd/standard" + "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" +) + +const ( + logFileName = "retina.log" +) + +type BootstrapManager struct { + metricsAddr string + probeAddr string + enableLeaderElection bool + configFile string +} + +func NewBootstrapManager(metricsAddr, probeAddr, configFile string, enableLeaderElection bool) *BootstrapManager { + return &BootstrapManager{ + metricsAddr: metricsAddr, + probeAddr: probeAddr, + enableLeaderElection: enableLeaderElection, + configFile: configFile, + } +} + +func (b *BootstrapManager) Start() error { + if buildinfo.ApplicationInsightsID != "" { + telemetry.InitAppInsights(buildinfo.ApplicationInsightsID, buildinfo.Version) + defer telemetry.ShutdownAppInsights() + defer telemetry.TrackPanic() + } + + daemonConfig, err := config.GetConfig(b.configFile) + if err != nil { + panic(err) + } + + fmt.Println("init logger") + zl, err := log.SetupZapLogger(&log.LogOpts{ + Level: daemonConfig.LogLevel, + File: false, + FileName: logFileName, + MaxFileSizeMB: 100, //nolint:gomnd // defaults + MaxBackups: 3, //nolint:gomnd // defaults + MaxAgeDays: 30, //nolint:gomnd // defaults + ApplicationInsightsID: buildinfo.ApplicationInsightsID, + EnableTelemetry: daemonConfig.EnableTelemetry, + }, + zap.String("version", buildinfo.Version), + zap.String("plugins", strings.Join(daemonConfig.EnabledPlugin, `,`)), + zap.String("data aggregation level", daemonConfig.DataAggregationLevel.String()), + ) + if err != nil { + panic(err) + } + defer zl.Close() + + if daemonConfig.EnableStandalone { + sd := standalone.NewDaemon(daemonConfig) + if err = sd.Start(zl); err != nil { + return fmt.Errorf("starting standalone daemon: %w", err) + } + return nil + } + + d := standard.NewDaemon(daemonConfig, b.metricsAddr, b.probeAddr, b.enableLeaderElection) + if err := d.Start(zl); err != nil { + return fmt.Errorf("starting daemon: %w", err) + } + return nil +} diff --git a/cmd/root.go b/cmd/root.go index 3f2fef1cff..f29bd670de 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -6,7 +6,6 @@ import ( "fmt" "os" - "github.com/microsoft/retina/cmd/standard" "github.com/spf13/cobra" ) @@ -27,9 +26,9 @@ var ( Long: "Start Retina Agent", RunE: func(cmd *cobra.Command, args []string) error { // Do Stuff Here - fmt.Println("Starting Retina Agent") - d := standard.NewDaemon(metricsAddr, probeAddr, cfgFile, enableLeaderElection) - if err := d.Start(); err != nil { + fmt.Println("Bootstrapping Retina") + b := NewBootstrapManager(metricsAddr, probeAddr, cfgFile, enableLeaderElection) + if err := b.Start(); err != nil { return fmt.Errorf("starting daemon: %w", err) } return nil diff --git a/cmd/standalone/daemon.go b/cmd/standalone/daemon.go new file mode 100644 index 0000000000..fb4a99d73d --- /dev/null +++ b/cmd/standalone/daemon.go @@ -0,0 +1,69 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package standalone + +import ( + "fmt" + "time" + + "github.com/microsoft/retina/cmd/telemetry" + "github.com/microsoft/retina/pkg/enricher" + "github.com/microsoft/retina/pkg/log" + "go.uber.org/zap" + ctrl "sigs.k8s.io/controller-runtime" + + "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/controllers/cache" + cm "github.com/microsoft/retina/pkg/managers/controllermanager" +) + +const TTL = 3 * time.Minute + +type Daemon struct { + config *config.Config +} + +func NewDaemon(daemonCfg *config.Config) *Daemon { + return &Daemon{ + config: daemonCfg, + } +} + +func (d *Daemon) Start(zl *log.ZapLogger) error { + zl.Info("Starting Standalone Retina daemon") + mainLogger := zl.Named("standalone-daemon").Sugar() + + tel, err := telemetry.InitializeTelemetryClient(nil, d.config, mainLogger) + if err != nil { + return fmt.Errorf("failed to initialize telemetry client: %w", err) + } + + ctx := ctrl.SetupSignalHandler() + + c := cache.NewStandaloneCache(TTL) + enrich := enricher.NewStandaloneEnricher(ctx, c, d.config) + enrich.Run() + + // pod level needs to be disabled + controllerMgr, err := cm.NewControllerManager(d.config, nil, tel) + if err != nil { + mainLogger.Fatal("Failed to create controller manager", zap.Error(err)) + } + if err := controllerMgr.Init(ctx); err != nil { + mainLogger.Fatal("Failed to initialize controller manager", zap.Error(err)) + } + + // start heartbeat goroutine for application insights + go tel.Heartbeat(ctx, d.config.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(ctx) + + mainLogger.Info("Network observability exiting. Till next time!") + return nil +} diff --git a/cmd/standard/daemon.go b/cmd/standard/daemon.go index 121bf70645..43c8003043 100644 --- a/cmd/standard/daemon.go +++ b/cmd/standard/daemon.go @@ -5,7 +5,6 @@ package standard import ( "fmt" "os" - "strings" "go.uber.org/zap" corev1 "k8s.io/api/core/v1" @@ -25,6 +24,7 @@ import ( metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server" "github.com/go-logr/zapr" + "github.com/microsoft/retina/cmd/telemetry" retinav1alpha1 "github.com/microsoft/retina/crd/api/v1alpha1" "github.com/microsoft/retina/internal/buildinfo" "github.com/microsoft/retina/pkg/config" @@ -35,20 +35,17 @@ import ( pc "github.com/microsoft/retina/pkg/controllers/daemon/pod" kec "github.com/microsoft/retina/pkg/controllers/daemon/retinaendpoint" sc "github.com/microsoft/retina/pkg/controllers/daemon/service" + "github.com/microsoft/retina/pkg/log" "github.com/microsoft/retina/pkg/enricher" - "github.com/microsoft/retina/pkg/log" cm "github.com/microsoft/retina/pkg/managers/controllermanager" "github.com/microsoft/retina/pkg/managers/filtermanager" "github.com/microsoft/retina/pkg/metrics" mm "github.com/microsoft/retina/pkg/module/metrics" "github.com/microsoft/retina/pkg/pubsub" - "github.com/microsoft/retina/pkg/telemetry" ) const ( - logFileName = "retina.log" - nodeNameEnvKey = "NODE_NAME" nodeIPEnvKey = "NODE_IP" ) @@ -62,73 +59,45 @@ func init() { } type Daemon struct { + config *config.Config metricsAddr string probeAddr string enableLeaderElection bool - configFile string } -func NewDaemon(metricsAddr, probeAddr, configFile string, enableLeaderElection bool) *Daemon { +func NewDaemon(daemoncfg *config.Config, metricsAddr, probeAddr string, enableLeaderElection bool) *Daemon { return &Daemon{ + config: daemoncfg, metricsAddr: metricsAddr, probeAddr: probeAddr, enableLeaderElection: enableLeaderElection, - configFile: configFile, } } -func (d *Daemon) Start() error { - fmt.Printf("starting Retina daemon with legacy control plane %v\n", buildinfo.Version) - - if buildinfo.ApplicationInsightsID != "" { - telemetry.InitAppInsights(buildinfo.ApplicationInsightsID, buildinfo.Version) - defer telemetry.ShutdownAppInsights() - defer telemetry.TrackPanic() - } - - daemonConfig, err := config.GetConfig(d.configFile) - if err != nil { - panic(err) - } - +func (d *Daemon) Start(zl *log.ZapLogger) error { + fmt.Printf("Starting Retina daemon with legacy control plane %v\n", buildinfo.Version) fmt.Println("init client-go") - var cfg *rest.Config + + var restCfg *rest.Config + var err error if kubeconfig := os.Getenv("KUBECONFIG"); kubeconfig != "" { - fmt.Println("KUBECONFIG set, using kubeconfig: ", kubeconfig) - cfg, err = clientcmd.BuildConfigFromFlags("", kubeconfig) + fmt.Println("KUBECONFIG detected, using kubeconfig: ", kubeconfig) + restCfg, err = clientcmd.BuildConfigFromFlags("", kubeconfig) if err != nil { return fmt.Errorf("creating controller-runtime manager: %w", err) } } else { - cfg, err = kcfg.GetConfig() + restCfg, err = kcfg.GetConfig() if err != nil { panic(err) } } - fmt.Println("api server: ", cfg.Host) - - fmt.Println("init logger") - zl, err := log.SetupZapLogger(&log.LogOpts{ - Level: daemonConfig.LogLevel, - File: false, - FileName: logFileName, - MaxFileSizeMB: 100, //nolint:gomnd // defaults - MaxBackups: 3, //nolint:gomnd // defaults - MaxAgeDays: 30, //nolint:gomnd // defaults - ApplicationInsightsID: buildinfo.ApplicationInsightsID, - EnableTelemetry: daemonConfig.EnableTelemetry, - }, - zap.String("version", buildinfo.Version), - zap.String("apiserver", cfg.Host), - zap.String("plugins", strings.Join(daemonConfig.EnabledPlugin, `,`)), - zap.String("data aggregation level", daemonConfig.DataAggregationLevel.String()), + fmt.Println("api server: ", restCfg.Host) + + mainLogger := zl.Named("main").Sugar().With( + "apiserver", restCfg.Host, ) - if err != nil { - panic(err) - } - defer zl.Close() - mainLogger := zl.Named("main").Sugar() // Allow the current process to lock memory for eBPF resources. // OS specific implementation. @@ -138,31 +107,14 @@ func (d *Daemon) Start() error { } metrics.InitializeMetrics() + mainLogger.Info(zap.String("data aggregation level", d.config.DataAggregationLevel.String())) - mainLogger.Info(zap.String("data aggregation level", daemonConfig.DataAggregationLevel.String())) - - var tel telemetry.Telemetry - if daemonConfig.EnableTelemetry { - if buildinfo.ApplicationInsightsID == "" { - panic("telemetry enabled, but ApplicationInsightsID is empty") - } - mainLogger.Info("telemetry enabled", zap.String("applicationInsightsID", buildinfo.ApplicationInsightsID)) - tel, err = telemetry.NewAppInsightsTelemetryClient("retina-agent", map[string]string{ - "version": buildinfo.Version, - "apiserver": cfg.Host, - "plugins": strings.Join(daemonConfig.EnabledPlugin, `,`), - }) - if err != nil { - mainLogger.Error("failed to create telemetry client", zap.Error(err)) - return fmt.Errorf("error when creating telemetry client: %w", err) - } - } else { - mainLogger.Info("telemetry disabled") - tel = telemetry.NewNoopTelemetry() + tel, err := telemetry.InitializeTelemetryClient(restCfg, d.config, mainLogger) + if err != nil { + return fmt.Errorf("failed to initialize telemetry client: %w", err) } // Create a manager for controller-runtime - mgrOption := crmgr.Options{ Scheme: scheme, Metrics: metricsserver.Options{ @@ -174,7 +126,7 @@ func (d *Daemon) Start() error { } // Local context has its meaning only when pod level(advanced) metrics is enabled. - if daemonConfig.EnablePodLevel && !daemonConfig.RemoteContext { + if d.config.EnablePodLevel && !d.config.RemoteContext { mainLogger.Info("Remote context is disabled, only pods deployed on the same node as retina-agent will be monitored") // the new cache sets Selector options on the Manager cache which are used // to perform *server-side* filtering of the cached objects. This is very important @@ -206,7 +158,7 @@ func (d *Daemon) Start() error { } } - mgr, err := crmgr.New(cfg, mgrOption) + mgr, err := crmgr.New(restCfg, mgrOption) if err != nil { mainLogger.Error("Unable to start manager", zap.Error(err)) return fmt.Errorf("creating controller-runtime manager: %w", err) @@ -236,7 +188,7 @@ func (d *Daemon) Start() error { ctx := ctrl.SetupSignalHandler() ctrl.SetLogger(zapr.NewLogger(zl.Logger.Named("controller-runtime"))) - if daemonConfig.EnablePodLevel { + if d.config.EnablePodLevel { pubSub := pubsub.New() controllerCache := controllercache.New(pubSub) enrich := enricher.New(ctx, controllerCache) @@ -247,16 +199,16 @@ func (d *Daemon) Start() error { } defer fm.Stop() //nolint:errcheck // best effort enrich.Run() - metricsModule := mm.InitModule(ctx, daemonConfig, pubSub, enrich, fm, controllerCache) + metricsModule := mm.InitModule(ctx, d.config, pubSub, enrich, fm, controllerCache) - if !daemonConfig.RemoteContext { + if !d.config.RemoteContext { mainLogger.Info("Initializing Pod controller") podController := pc.New(mgr.GetClient(), controllerCache) if err := podController.SetupWithManager(mgr); err != nil { mainLogger.Fatal("unable to create PodController", zap.Error(err)) } - } else if daemonConfig.EnableRetinaEndpoint { + } else if d.config.EnableRetinaEndpoint { mainLogger.Info("RetinaEndpoint is enabled") mainLogger.Info("Initializing RetinaEndpoint controller") @@ -278,7 +230,7 @@ func (d *Daemon) Start() error { mainLogger.Fatal("unable to create svcController", zap.Error(err)) } - if daemonConfig.EnableAnnotations { + if d.config.EnableAnnotations { mainLogger.Info("Initializing MetricsConfig namespaceController") namespaceController := namespacecontroller.New(mgr.GetClient(), controllerCache, metricsModule) if err := namespaceController.SetupWithManager(mgr); err != nil { @@ -294,7 +246,7 @@ func (d *Daemon) Start() error { } } - controllerMgr, err := cm.NewControllerManager(daemonConfig, cl, tel) + controllerMgr, err := cm.NewControllerManager(d.config, cl, tel) if err != nil { mainLogger.Fatal("Failed to create controller manager", zap.Error(err)) } @@ -307,7 +259,7 @@ func (d *Daemon) Start() error { defer controllerMgr.Stop(ctx) // start heartbeat goroutine for application insights - go tel.Heartbeat(ctx, daemonConfig.TelemetryInterval) + go tel.Heartbeat(ctx, d.config.TelemetryInterval) // Start controller manager, which will start http server and plugin manager. go controllerMgr.Start(ctx) diff --git a/cmd/telemetry/telemetry.go b/cmd/telemetry/telemetry.go new file mode 100644 index 0000000000..04569e4bfc --- /dev/null +++ b/cmd/telemetry/telemetry.go @@ -0,0 +1,48 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package telemetry + +import ( + "fmt" + "strings" + + "github.com/microsoft/retina/internal/buildinfo" + "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/telemetry" + "go.uber.org/zap" + "k8s.io/client-go/rest" +) + +func InitializeTelemetryClient(restCfg *rest.Config, dcfg *config.Config, ml *zap.SugaredLogger) (telemetry.Telemetry, error) { + if dcfg.EnableTelemetry { + if buildinfo.ApplicationInsightsID == "" { + panic("telemetry enabled, but ApplicationInsightsID is empty") + } + ml.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(dcfg.EnabledPlugin, `,`), + }) + } else { + tel, err = telemetry.NewAppInsightsTelemetryClient("standalone-retina-agent", map[string]string{ + "version": buildinfo.Version, + "plugins": strings.Join(dcfg.EnabledPlugin, `,`), + }) + } + if err != nil { + ml.Error("failed to create telemetry client", zap.Error(err)) + return tel, fmt.Errorf("error when creating telemetry client: %w", err) + } + return tel, nil + } + + ml.Info("telemetry disabled") + tel := telemetry.NewNoopTelemetry() + return tel, nil +} diff --git a/go.mod b/go.mod index 797135515a..4b7f4c8433 100644 --- a/go.mod +++ b/go.mod @@ -317,6 +317,7 @@ require ( k8s.io/metrics v0.32.3 k8s.io/perf-tests/network/benchmarks/netperf v0.0.0-00010101000000-000000000000 sigs.k8s.io/controller-runtime v0.20.4 + sigs.k8s.io/kind v0.23.0 ) require ( @@ -659,7 +660,6 @@ require ( sigs.k8s.io/controller-runtime/tools/setup-envtest v0.0.0-20211110210527-619e6b92dab9 // indirect sigs.k8s.io/controller-tools v0.16.5 // indirect sigs.k8s.io/gateway-api v1.2.1-0.20250319040149-e8b8afabf889 // indirect - sigs.k8s.io/kind v0.23.0 // indirect sigs.k8s.io/mcs-api v0.1.1-0.20250224121229-6c631f4730d0 // indirect sigs.k8s.io/mcs-api/controllers v0.0.0-20250224121229-6c631f4730d0 // indirect sigs.k8s.io/randfill v1.0.0 // indirect diff --git a/pkg/config/config.go b/pkg/config/config.go index 0ac6b1cb06..7bf73bd3c8 100644 --- a/pkg/config/config.go +++ b/pkg/config/config.go @@ -68,6 +68,8 @@ type Config struct { EnableTelemetry bool `yaml:"enableTelemetry"` EnableRetinaEndpoint bool `yaml:"enableRetinaEndpoint"` EnablePodLevel bool `yaml:"enablePodLevel"` + EnableStandalone bool `yaml:"enableStandalone"` + EnableCrictl bool `yaml:"enableCrictl"` EnableConntrackMetrics bool `yaml:"enableConntrackMetrics"` RemoteContext bool `yaml:"remoteContext"` EnableAnnotations bool `yaml:"enableAnnotations"` diff --git a/pkg/controllers/cache/standalone_cache.go b/pkg/controllers/cache/standalone_cache.go new file mode 100644 index 0000000000..5724275021 --- /dev/null +++ b/pkg/controllers/cache/standalone_cache.go @@ -0,0 +1,95 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package cache + +import ( + "sync" + "time" + + "github.com/microsoft/retina/pkg/log" + "go.uber.org/zap" +) + +type PodInfo struct { + Name string + Namespace string + LastUpdate time.Time +} + +type StandaloneCache struct { + rwMutex sync.RWMutex + l *log.ZapLogger + ipToPod map[string]*PodInfo + ttl time.Duration +} + +func NewStandaloneCache(ttl time.Duration) *StandaloneCache { + return &StandaloneCache{ + l: log.Logger().Named(string("standalone-cache")), + ipToPod: make(map[string]*PodInfo), + ttl: ttl, + } +} + +func (c *StandaloneCache) GetPod(ip string) *PodInfo { + c.rwMutex.RLock() + defer c.rwMutex.RUnlock() + + if pod, exists := c.ipToPod[ip]; exists { + return pod + } + return nil +} + +func (c *StandaloneCache) Update(ip string, podInfo *PodInfo) { + if podInfo != nil { + c.addPod(ip, podInfo.Name, podInfo.Namespace) + } else { + c.deletePod(ip) + } +} + +func (c *StandaloneCache) ForEach(f func(ip string, podInfo *PodInfo)) { + c.rwMutex.RLock() + defer c.rwMutex.RUnlock() + + for ip, podInfo := range c.ipToPod { + f(ip, podInfo) + } +} + +func (c *StandaloneCache) TTL() time.Duration { + return c.ttl +} + +func (c *StandaloneCache) addPod(ip, name, namespace string) { + c.rwMutex.Lock() + defer c.rwMutex.Unlock() + + existingPod, exists := c.ipToPod[ip] + newPod := &PodInfo{Name: name, Namespace: namespace, LastUpdate: time.Now()} + + // Skip adding element if identical + if exists && existingPod.isEqual(newPod) { + existingPod.LastUpdate = time.Now() + return + } + + c.ipToPod[ip] = newPod + c.l.Info("Added pod to cache", zap.String("ip", ip), zap.String("pod", name), zap.String("namespace", namespace)) +} + +func (c *StandaloneCache) deletePod(ip string) { + c.rwMutex.Lock() + defer c.rwMutex.Unlock() + + if podInfo, exists := c.ipToPod[ip]; exists { + delete(c.ipToPod, ip) + c.l.Info("Deleted pod from cache", zap.String("ip", ip), zap.String("pod", podInfo.Name), zap.String("namespace", podInfo.Namespace)) + } +} + +func (c *PodInfo) isEqual(other *PodInfo) bool { + return c.Name == other.Name && c.Namespace == other.Namespace +} diff --git a/pkg/controllers/cache/standalone_cache_test.go b/pkg/controllers/cache/standalone_cache_test.go new file mode 100644 index 0000000000..7a9737a738 --- /dev/null +++ b/pkg/controllers/cache/standalone_cache_test.go @@ -0,0 +1,164 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package cache + +import ( + "testing" + "time" + + "github.com/microsoft/retina/pkg/log" + "github.com/stretchr/testify/require" +) + +var ( + ip = "10.0.0.1" + p1 = &PodInfo{Name: "pod1", Namespace: "ns1"} + ttl = 3 * time.Minute +) + +func TestCacheAddPod(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + c := NewStandaloneCache(ttl) + + p2 := &PodInfo{Name: "pod2", Namespace: "ns2"} + p3 := &PodInfo{Name: "pod1", Namespace: "ns1"} + + tests := []struct { + name string + ip string + pod string + namespace string + expectedPod string + expectedNS string + }{ + { + name: "Add new pod", + ip: ip, + pod: p1.Name, + namespace: p1.Namespace, + expectedPod: p1.Name, + expectedNS: p1.Namespace, + }, + { + name: "Add identical pod", + ip: ip, + pod: p3.Name, + namespace: p3.Namespace, + expectedPod: p1.Name, + expectedNS: p1.Namespace, + }, + { + name: "Update pod info for same IP", + ip: ip, + pod: p2.Name, + namespace: p2.Namespace, + expectedPod: p2.Name, + expectedNS: p2.Namespace, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c.addPod(tt.ip, tt.pod, tt.namespace) + + got := c.GetPod(tt.ip) + require.NotNil(t, got, "Expected pod info, got nil") + require.Equal(t, tt.expectedPod, got.Name) + require.Equal(t, tt.expectedNS, got.Namespace) + }) + } +} + +func TestCacheDeletePod(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + c := NewStandaloneCache(ttl) + + tests := []struct { + name string + setup func() + ip string + expectedPodInfo *PodInfo + }{ + { + name: "Delete existing pod", + setup: func() { + c.addPod(ip, p1.Name, p1.Namespace) + }, + ip: ip, + expectedPodInfo: nil, + }, + { + name: "Delete non-existing pod (no-op)", + setup: func() {}, + ip: "10.0.0.2", + expectedPodInfo: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.setup() + c.deletePod(tt.ip) + + got := c.GetPod(tt.ip) + require.Equal(t, tt.expectedPodInfo, got) + }) + } +} + +func TestCacheUpdate(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + c := NewStandaloneCache(ttl) + + tests := []struct { + name string + ip string + podInfo *PodInfo + expectedPodInfo *PodInfo + }{ + { + name: "Add Pod", + ip: ip, + podInfo: p1, + expectedPodInfo: p1, + }, + { + name: "Delete Pod", + ip: ip, + podInfo: nil, + expectedPodInfo: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c.Update(tt.ip, tt.podInfo) + + got := c.GetPod(tt.ip) + if tt.expectedPodInfo == nil { + require.Nil(t, got, "Expected nil pod info, got %v", got) + } else { + require.NotNil(t, got != nil, "Expected pod info, got nil") + require.Equal(t, tt.expectedPodInfo.Name, got.Name) + require.Equal(t, tt.expectedPodInfo.Namespace, got.Namespace) + } + }) + } +} + +func TestCacheTTL(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + c := NewStandaloneCache(ttl) + + cacheTime := c.TTL() + require.Equal(t, cacheTime, ttl) +} diff --git a/pkg/enricher/ctrinfo/helper.go b/pkg/enricher/ctrinfo/helper.go new file mode 100644 index 0000000000..044604cf2b --- /dev/null +++ b/pkg/enricher/ctrinfo/helper.go @@ -0,0 +1,83 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package ctrinfo + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "os/exec" + "strings" + "time" + + "github.com/microsoft/retina/pkg/controllers/cache" +) + +type PodSpec struct { + Status Status `json:"status"` +} + +type Status struct { + Metadata Metadata `json:"metadata"` + Network Network `json:"network"` +} + +type Metadata struct { + Name string `json:"name"` + Namespace string `json:"namespace"` +} + +type Network struct { + IP string `json:"ip"` +} + +var crictlCommand = runCommand + +func GetPodInfo(ip string) (*cache.PodInfo, error) { + runningPods, err := crictlCommand("cmd", "/c", "crictl", "pods", "-q") + if err != nil { + return nil, fmt.Errorf("failed to get running pods: %w", err) + } + + podIDs := strings.Split(strings.TrimSpace(runningPods), "\n") + for _, podID := range podIDs { + if podID == "" { + continue + } + + podSpec, err := crictlCommand("cmd", "/c", "crictl", "inspectp", podID) + if err != nil { + return nil, fmt.Errorf("failed to inspect pod information: %w", err) + } + + var spec PodSpec + if err := json.Unmarshal([]byte(podSpec), &spec); err != nil { + return nil, fmt.Errorf("error unmarshalling JSON: %w", err) + } + + if spec.Status.Network.IP == ip { + return &cache.PodInfo{ + Name: spec.Status.Metadata.Name, + Namespace: spec.Status.Metadata.Namespace, + }, nil + } + } + + return nil, nil +} + +func runCommand(command string, args ...string) (string, error) { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + cmd := exec.CommandContext(ctx, command, args...) + var output bytes.Buffer + cmd.Stdout = &output + err := cmd.Run() + if err != nil { + return "", fmt.Errorf("failed to run command: %w", err) + } + return output.String(), nil +} diff --git a/pkg/enricher/ctrinfo/helper_test.go b/pkg/enricher/ctrinfo/helper_test.go new file mode 100644 index 0000000000..9dbe747894 --- /dev/null +++ b/pkg/enricher/ctrinfo/helper_test.go @@ -0,0 +1,116 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package ctrinfo + +import ( + "os" + "strings" + "testing" + + "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/stretchr/testify/require" + "sigs.k8s.io/kind/pkg/errors" +) + +var ( + errGetPods = errors.New("Failed to get running pods") + errInspectPod = errors.New("Failed to inspect pod information") + errJSONRead = errors.New("unexpected end of JSON input") +) + +func TestGetPodInfo(t *testing.T) { + invalidJSONPath := "invalid_pod_spec.json" + invalidJSONContent := `{"status": {"metadata": {"name": "retina-pod", "namespace": "retina-namespace"}` + + err := os.WriteFile(invalidJSONPath, []byte(invalidJSONContent), 0o600) + require.NoError(t, err, "failed to create invalid JSON file") + defer os.Remove(invalidJSONPath) + + tests := []struct { + name string + ip string + podCmdOutput string + inspectCmdOutput string + getPodsErr error + inspectPodErr error + expectedErr error + expectedPodInfo *cache.PodInfo + }{ + { + name: "IP found in list of running pods", + ip: "10.0.0.4", + podCmdOutput: "pod1\npod2\n", + inspectCmdOutput: "mock_podSpec.json", + expectedErr: nil, + expectedPodInfo: &cache.PodInfo{Name: "retina-pod", Namespace: "retina-namespace"}, + }, + { + name: "No IP found in list of running pods", + ip: "10.0.0.0", + podCmdOutput: "pod1\npod2\n", + inspectCmdOutput: "mock_podSpec.json", + expectedErr: nil, + expectedPodInfo: nil, + }, + { + name: "Invalid pod spec JSON", + ip: "10.0.0.4", + podCmdOutput: "pod1\npod2\n", + inspectCmdOutput: invalidJSONPath, + expectedErr: errJSONRead, + expectedPodInfo: nil, + }, + { + name: "Running pods error", + ip: "10.0.0.0", + getPodsErr: errGetPods, + expectedErr: errGetPods, + expectedPodInfo: nil, + }, + { + name: "Inspect pod error", + ip: "10.0.0.4", + podCmdOutput: "pod1\npod2\n", + inspectPodErr: errInspectPod, + expectedErr: errInspectPod, + expectedPodInfo: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + crictlCommand = func(_ string, args ...string) (string, error) { + if strings.Contains(args[2], "pods") { + if tt.getPodsErr != nil { + return "", tt.getPodsErr + } + return tt.podCmdOutput, nil + } + if strings.Contains(args[2], "inspectp") { + if tt.inspectPodErr != nil { + return "", tt.inspectPodErr + } + content, err := os.ReadFile(tt.inspectCmdOutput) + if err != nil { + return "", errJSONRead + } + return string(content), nil + } + return "", errors.New("unknown command") + } + + podInfo, err := GetPodInfo(tt.ip) + if tt.expectedErr != nil { + require.Error(t, err) + require.ErrorContains(t, err, tt.expectedErr.Error()) + require.Nil(t, podInfo) + } else { + require.NoError(t, err) + require.Equal(t, tt.expectedPodInfo, podInfo) + } + + crictlCommand = runCommand + }) + } +} diff --git a/pkg/enricher/ctrinfo/mock_podSpec.json b/pkg/enricher/ctrinfo/mock_podSpec.json new file mode 100644 index 0000000000..70ca17934d --- /dev/null +++ b/pkg/enricher/ctrinfo/mock_podSpec.json @@ -0,0 +1,99 @@ +{ + "status": { + "id": "X", + "metadata": { + "attempt": 1, + "name": "retina-pod", + "namespace": "retina-namespace", + "uid": "" + }, + "state": "SANDBOX_READY", + "createdAt": "X", + "network": { + "additionalIps": [], + "ip": "10.0.0.4" + }, + "linux": { + "namespaces": { + "options": { + "ipc": "POD", + "network": "POD", + "pid": "POD", + "targetId": "" + } + } + }, + "labels": { + "sandbox-platform": "windows/amd64" + }, + "annotations": {}, + "runtimeHandler": "runhcs-wcow-process" + }, + "info": { + "pid": 9324, + "processStatus": "running", + "netNamespaceClosed": false, + "image": "mcr.microsoft.com/windows/nanoserver:ltsc2022", + "snapshotKey": "X", + "snapshotter": "windows", + "runtimeHandler": "runhcs-wcow-process", + "runtimeType": "io.containerd.runhcs.v1", + "runtimeOptions": { + "debug": true, + "debug_type": 2, + "sandbox_image": "mcr.microsoft.com/windows/nanoserver:ltsc2022", + "sandbox_platform": "windows/amd64" + }, + "config": { + "metadata": { + "name": "retina-pod", + "namespace": "retina-namespace", + "attempt": 1 + }, + "labels": { + "sandbox-platform": "windows/amd64" + } + }, + "runtimeSpec": { + "ociVersion": "1.0.2", + "process": { + "user": { + "uid": 0, + "gid": 0 + }, + "args": [ + "c:\\windows\\system32\\cmd.exe" + ], + "cwd": "C:\\" + }, + "annotations": { + "io.kubernetes.cri.container-type": "sandbox", + "io.kubernetes.cri.sandbox-id": "X" + }, + "windows": { + "layerFolders": null, + "network": { + "networkNamespace": "X" + } + } + }, + "cniResult": { + "Interfaces": { + "eth0": { + "IPConfigs": [ + { + "IP": "10.0.0.4", + "Gateway": "10.0.0.1" + } + ], + "Mac": "", + "Sandbox": "" + } + }, + "DNS": [ + {} + ], + "Routes": null + } + } +} \ No newline at end of file diff --git a/pkg/enricher/standalone.go b/pkg/enricher/standalone.go new file mode 100644 index 0000000000..2900f85d57 --- /dev/null +++ b/pkg/enricher/standalone.go @@ -0,0 +1,151 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package enricher + +import ( + "context" + "errors" + "sync" + "time" + + "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/controllers/cache" + ctr "github.com/microsoft/retina/pkg/enricher/ctrinfo" + sf "github.com/microsoft/retina/pkg/enricher/statefile" + "github.com/microsoft/retina/pkg/log" + "go.uber.org/zap" +) + +var ( + se *StandaloneEnricher + localOnce sync.Once +) + +var ( + MaxStandaloneCacheEventSize = 250 + ErrEventChannelFull = errors.New("event channel is full, event dropped") +) + +type Action string + +const ( + AddEvent Action = "add" + DeleteEvent Action = "delete" +) + +type StandaloneEvent struct { + IP string + Action Action +} + +type StandaloneEnricher struct { + cfg *config.Config + ctx context.Context + l *log.ZapLogger + cache *cache.StandaloneCache + eventChannel chan StandaloneEvent +} + +func NewEnricher(ctx context.Context, standaloneCache *cache.StandaloneCache, cfg *config.Config) *StandaloneEnricher { + return &StandaloneEnricher{ + cfg: cfg, + ctx: ctx, + l: log.Logger().Named("standalone-enricher"), + cache: standaloneCache, + eventChannel: make(chan StandaloneEvent, MaxStandaloneCacheEventSize), + } +} + +func NewStandaloneEnricher(ctx context.Context, standaloneCache *cache.StandaloneCache, cfg *config.Config) *StandaloneEnricher { + localOnce.Do(func() { + se = NewEnricher(ctx, standaloneCache, cfg) + }) + return se +} + +func StandaloneInstance() *StandaloneEnricher { + return se +} + +func (e *StandaloneEnricher) Run() { + e.l.Info("Running standalone enricher") + if e.cfg.EnableCrictl { + e.l.Info("Using crictl enrichment") + } else { + e.l.Info("Using statefile enrichment") + } + + go func() { + for { + select { + case <-e.ctx.Done(): + e.l.Info("Standalone enricher shutting down...") + return + case event, ok := <-e.eventChannel: + if !ok { + e.l.Info("Event channel closed, stopping event processing") + return + } + switch event.Action { + case AddEvent: + e.l.Debug("Processing add event", zap.String("ip", event.IP)) + e.enrich(event.IP) + case DeleteEvent: + e.l.Debug("Processing delete event", zap.String("ip", event.IP)) + e.cache.Update(event.IP, nil) + default: + e.l.Warn("Unknown event action", zap.String("action", string(event.Action))) + } + } + } + }() +} + +func (e *StandaloneEnricher) enrich(ip string) { + var podInfo *cache.PodInfo + var err error + + if e.cfg.EnableCrictl { + podInfo, err = ctr.GetPodInfo(ip) + } else { + podInfo, err = sf.GetPodInfo(ip, sf.StateFileLocation) + } + + if err != nil { + e.l.Error("Failed to get pod info", zap.String("ip", ip), zap.Error(err)) + return + } + e.cache.Update(ip, podInfo) +} + +func (e *StandaloneEnricher) GetPodInfo(ip string) *cache.PodInfo { + return e.cache.GetPod(ip) +} + +func (e *StandaloneEnricher) PublishEvent(ip string, action Action) error { + select { + case e.eventChannel <- StandaloneEvent{IP: ip, Action: action}: + return nil + default: + e.l.Warn("Event channel full, dropping event", zap.String("ip", ip)) + return ErrEventChannelFull + } +} + +func (e *StandaloneEnricher) RemoveStaleEntries() { + e.cache.ForEach(func(ip string, podInfo *cache.PodInfo) { + if time.Since(podInfo.LastUpdate) > e.cache.TTL() { + e.l.Info("Removing stale entry from cache", zap.String("ip", ip)) + err := e.PublishEvent(ip, DeleteEvent) + if err != nil { + e.l.Error("Failed to publish delete event", zap.String("ip", ip), zap.Error(err)) + } + } + }) +} + +func (e *StandaloneEnricher) Stop() { + e.l.Info("Stopping standalone enricher...") + close(e.eventChannel) +} diff --git a/pkg/enricher/standalone_test.go b/pkg/enricher/standalone_test.go new file mode 100644 index 0000000000..942146e61d --- /dev/null +++ b/pkg/enricher/standalone_test.go @@ -0,0 +1,156 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package enricher + +import ( + "context" + "testing" + "time" + + "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/controllers/cache" + sf "github.com/microsoft/retina/pkg/enricher/statefile" + "github.com/microsoft/retina/pkg/log" + "github.com/stretchr/testify/require" +) + +const testIP = "10.0.0.0" + +func TestPublishEvent(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + MaxStandaloneCacheEventSize = 1 + + tests := []struct { + name string + fillChannel bool + event StandaloneEvent + expectedErr error + }{ + { + name: "Event published successfully", + fillChannel: false, + event: StandaloneEvent{IP: testIP, Action: AddEvent}, + expectedErr: nil, + }, + { + name: "Event channel is full", + fillChannel: true, + event: StandaloneEvent{IP: testIP, Action: AddEvent}, + expectedErr: ErrEventChannelFull, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if tt.fillChannel { + MaxStandaloneCacheEventSize = 0 + } + + testCache := cache.NewStandaloneCache(10 * time.Second) + e := NewEnricher(context.Background(), testCache, &config.Config{}) + + err := e.PublishEvent(tt.event.IP, tt.event.Action) + if tt.expectedErr != nil { + require.Error(t, err) + require.Equal(t, tt.expectedErr, err) + } else { + require.NoError(t, err) + } + }) + } +} + +func TestRemoveStaleEntries(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + + sf.StateFileLocation = "statefile/mock_statefile.json" + testCache := cache.NewStandaloneCache(1 * time.Millisecond) + e := NewEnricher(context.Background(), testCache, &config.Config{}) + e.Run() + defer e.Stop() + + podInfo := cache.PodInfo{Name: "retina-pod", Namespace: "retina-namespace", LastUpdate: time.Now()} + + testCache.Update(testIP, &podInfo) + time.Sleep(50 * time.Millisecond) + e.RemoveStaleEntries() + + require.Eventually(t, func() bool { + return testCache.GetPod(testIP) == nil + }, 100*time.Millisecond, 10*time.Millisecond, "Expected pod info should be nil after TTL expired") +} + +func TestRun(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + existingIP := "192.0.0.5" + nonExistingIP := testIP + + name := "retina-pod" + namespace := "retina-namespace" + sf.StateFileLocation = "statefile/mock_statefile.json" + MaxStandaloneCacheEventSize = 250 + + tests := []struct { + name string + event StandaloneEvent + setupCache func(c *cache.StandaloneCache) + expectedPodInfo *cache.PodInfo + }{ + { + name: "Successful cache update", + event: StandaloneEvent{IP: existingIP, Action: AddEvent}, + setupCache: func(_ *cache.StandaloneCache) {}, + expectedPodInfo: &cache.PodInfo{Name: name, Namespace: namespace}, + }, + { + name: "Successful cache deletion", + event: StandaloneEvent{IP: existingIP, Action: DeleteEvent}, + setupCache: func(c *cache.StandaloneCache) { + podInfo := cache.PodInfo{Name: name, Namespace: namespace} + c.Update(existingIP, &podInfo) + }, + expectedPodInfo: nil, + }, + { + name: "No update when pod info is empty", + event: StandaloneEvent{IP: nonExistingIP, Action: AddEvent}, + setupCache: func(_ *cache.StandaloneCache) {}, + expectedPodInfo: nil, + }, + { + name: "No update for unknown event", + event: StandaloneEvent{IP: existingIP, Action: Action("unknown")}, + setupCache: func(_ *cache.StandaloneCache) {}, + expectedPodInfo: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + testCache := cache.NewStandaloneCache(1 * time.Second) + e := NewEnricher(context.Background(), testCache, &config.Config{EnableCrictl: false}) + tt.setupCache(testCache) + + e.Run() + defer e.Stop() + + err := e.PublishEvent(tt.event.IP, tt.event.Action) + require.NoError(t, err) + + require.Eventually(t, func() bool { + podInfo := testCache.GetPod(tt.event.IP) + if tt.expectedPodInfo == nil { + return podInfo == nil + } + return podInfo != nil && podInfo.Name == tt.expectedPodInfo.Name && podInfo.Namespace == tt.expectedPodInfo.Namespace + }, 100*time.Millisecond, 10*time.Millisecond, "Pod info should match the expected pod info") + }) + } +} diff --git a/pkg/enricher/enricher.go b/pkg/enricher/standard.go similarity index 100% rename from pkg/enricher/enricher.go rename to pkg/enricher/standard.go diff --git a/pkg/enricher/enricher_test.go b/pkg/enricher/standard_test.go similarity index 100% rename from pkg/enricher/enricher_test.go rename to pkg/enricher/standard_test.go diff --git a/pkg/enricher/statefile/helper.go b/pkg/enricher/statefile/helper.go new file mode 100644 index 0000000000..4b8ef7663c --- /dev/null +++ b/pkg/enricher/statefile/helper.go @@ -0,0 +1,75 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package statefile + +import ( + "encoding/json" + "fmt" + "os" + + "github.com/microsoft/retina/pkg/controllers/cache" +) + +var StateFileLocation = "C:/Windows/System32/azure-vnet.json" + +type CniState struct { + Network Network `json:"Network"` +} + +type Network struct { + ExternalInterfaces map[string]ExternalInterface `json:"ExternalInterfaces"` +} + +type ExternalInterface struct { + Networks map[string]NetworkInfo `json:"Networks"` +} + +type NetworkInfo struct { + Endpoints map[string]Endpoint `json:"Endpoints"` +} + +type Endpoint struct { + ID string `json:"Id"` + IPAddresses []IPInfo `json:"IPAddresses"` + PodName string `json:"PodName"` + PodNamespace string `json:"PodNamespace"` +} + +type IPInfo struct { + IP string `json:"IP"` +} + +func GetPodInfo(ip, filePath string) (*cache.PodInfo, error) { + data, err := os.ReadFile(filePath) + if err != nil { + return nil, fmt.Errorf("failed to read CNI state file: %w", err) + } + + if len(data) == 0 { + return nil, nil + } + + var cniState CniState + if err := json.Unmarshal(data, &cniState); err != nil { + return nil, fmt.Errorf("failed to decode CNI state file: %w", err) + } + + // For every HNS endpoint, we check if the equivalent IP address exists in the CNI state file + for _, iface := range cniState.Network.ExternalInterfaces { + for _, networkInfo := range iface.Networks { + for _, endpoint := range networkInfo.Endpoints { + for _, ipInfo := range endpoint.IPAddresses { + if ipInfo.IP == ip { + return &cache.PodInfo{ + Name: endpoint.PodName, + Namespace: endpoint.PodNamespace, + }, nil + } + } + } + } + } + + return nil, nil +} diff --git a/pkg/enricher/statefile/helper_test.go b/pkg/enricher/statefile/helper_test.go new file mode 100644 index 0000000000..970fd23b8b --- /dev/null +++ b/pkg/enricher/statefile/helper_test.go @@ -0,0 +1,103 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package statefile + +import ( + "os" + "testing" + + "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/stretchr/testify/require" +) + +func TestGetPodInfo(t *testing.T) { + emptyJSONPath := "empty_azure_vnet.json" + emptyJSONContent := `` + err := os.WriteFile(emptyJSONPath, []byte(emptyJSONContent), 0o600) + require.NoError(t, err, "failed to create empty JSON file") + + invalidJSONPath := "mock_invalid_azure_vnet.json" + invalidJSONContent := `{ + "Network": { + "ExternalInterfaces": { + "eth0": { + "Networks": { + "192.0.0.5": { + "IpAddresses": [ + { + "IP": "192.0.0.5" + } + ], + "PodName": "retina2-pod", + "PodNamespace": "retina2-namespace" + } + } + } + } + } + ` + err = os.WriteFile(invalidJSONPath, []byte(invalidJSONContent), 0o600) + require.NoError(t, err, "failed to create invalid JSON file") + + defer os.Remove(emptyJSONPath) + defer os.Remove(invalidJSONPath) + + tests := []struct { + name string + ip string + filePath string + expectedPodInfo *cache.PodInfo + expectedErr bool + }{ + { + name: "Valid IP match", + ip: "192.0.0.5", + filePath: "mock_statefile.json", + expectedPodInfo: &cache.PodInfo{Name: "retina-pod", Namespace: "retina-namespace"}, + expectedErr: false, + }, + { + name: "No IP match", + ip: "10.0.0.0", + filePath: "mock_statefile.json", + expectedPodInfo: nil, + expectedErr: false, + }, + { + name: "CNI state file not found", + ip: "10.0.0.0", + filePath: "non_existent_file.json", + expectedPodInfo: nil, + expectedErr: true, + }, + { + name: "Empty CNI state file", + ip: "10.0.0.0", + filePath: emptyJSONPath, + expectedPodInfo: nil, + expectedErr: false, + }, + { + name: "Invalid state file JSON", + ip: "10.0.0.0", + filePath: invalidJSONPath, + expectedPodInfo: nil, + expectedErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + podInfo, err := GetPodInfo(tt.ip, tt.filePath) + + if tt.expectedErr { + require.Error(t, err) + require.Nil(t, podInfo) + } else { + require.NoError(t, err) + require.Equal(t, tt.expectedPodInfo, podInfo) + } + }) + } +} diff --git a/pkg/enricher/statefile/mock_statefile.json b/pkg/enricher/statefile/mock_statefile.json new file mode 100644 index 0000000000..4437a77a94 --- /dev/null +++ b/pkg/enricher/statefile/mock_statefile.json @@ -0,0 +1,37 @@ +{ + "Network": { + "ExternalInterfaces": { + "Ethernet": { + "Name": "Ethernet", + "Networks": { + "mock_network": { + "Endpoints": { + "mock_endpoint_1": { + "Id": "X", + "IPAddresses": [ + { + "IP": "192.0.0.5", + "Mask": "X" + } + ], + "PODName": "retina-pod", + "PODNameSpace": "retina-namespace" + }, + "mock_endpoint_2": { + "Id": "Y", + "IPAddresses": [ + { + "IP": "192.0.0.4", + "Mask": "Y" + } + ], + "PODName": "retina2-pod", + "PODNameSpace": "retina2-namespace" + } + } + } + } + } + } + } +} \ No newline at end of file diff --git a/pkg/metrics/metrics.go b/pkg/metrics/metrics.go index 9169a08d8d..353af7e56b 100644 --- a/pkg/metrics/metrics.go +++ b/pkg/metrics/metrics.go @@ -42,8 +42,8 @@ func InitializeMetrics() { utils.Direction) HNSStatsGauge = exporter.CreatePrometheusGaugeVecForMetric( exporter.DefaultRegistry, - hnsStats, - hnsStatsDescription, + HNSStats, + HNSStatsDescription, utils.Direction, ) NodeConnectivityStatusGauge = exporter.CreatePrometheusGaugeVecForMetric( @@ -74,14 +74,14 @@ func InitializeMetrics() { TCPConnectionStatsGauge = exporter.CreatePrometheusGaugeVecForMetric( exporter.DefaultRegistry, utils.TCPConnectionStatsName, - tcpConnectionStatsGaugeDescription, + TCPConnectionStatsGaugeDescription, utils.StatName, ) TCPFlagGauge = exporter.CreatePrometheusGaugeVecForMetric( exporter.DefaultRegistry, utils.TCPFlagGauge, - tcpFlagGaugeDescription, + TCPFlagGaugeDescription, utils.Direction, utils.Flag, ) diff --git a/pkg/metrics/types.go b/pkg/metrics/types.go index 0803f62a71..8b82f16de6 100644 --- a/pkg/metrics/types.go +++ b/pkg/metrics/types.go @@ -15,8 +15,8 @@ const ( parsedPacketsCounterName = "parsed_packets_counter" // Windows - hnsStats = "windows_hns_stats" - hnsStatsDescription = "Include many different metrics from packets sent/received to closed connections" + HNSStats = "windows_hns_stats" + HNSStatsDescription = "Include many different metrics from packets sent/received to closed connections" // Linux only metrics (for now). nodeApiServerHandshakeLatencyHistName = "node_apiserver_handshake_latency_ms" @@ -30,8 +30,8 @@ const ( nodeConnectivityLatencySecondsGaugeDescription = "The last observed latency between the current Cilium agent and other Cilium nodes in seconds" tcpStateGaugeDescription = "Number of active TCP connections by state" tcpConnectionRemoteGaugeDescription = "Number of active TCP connections by remote address" - tcpConnectionStatsGaugeDescription = "TCP connections statistics" - tcpFlagGaugeDescription = "TCP gauges by flag" + TCPConnectionStatsGaugeDescription = "TCP connections statistics" + TCPFlagGaugeDescription = "TCP gauges by flag" ipConnectionStatsGaugeDescription = "IP connections statistics" udpConnectionStatsGaugeDescription = "UDP connections statistics" interfaceStatsGaugeDescription = "Interface statistics" diff --git a/pkg/plugin/hnsstats/hnsstats_windows.go b/pkg/plugin/hnsstats/hnsstats_windows.go index dd93db438f..08444679b4 100644 --- a/pkg/plugin/hnsstats/hnsstats_windows.go +++ b/pkg/plugin/hnsstats/hnsstats_windows.go @@ -7,12 +7,14 @@ package hnsstats import ( "context" "encoding/json" + "fmt" "time" "github.com/Microsoft/hcsshim" "github.com/Microsoft/hcsshim/hcn" v1 "github.com/cilium/cilium/pkg/hubble/api/v1" kcfg "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/enricher" "github.com/microsoft/retina/pkg/log" "github.com/microsoft/retina/pkg/metrics" "github.com/microsoft/retina/pkg/plugin/registry" @@ -78,12 +80,27 @@ func (h *hnsstats) Init() error { Flags: hcn.HostComputeQueryFlagsNone, } // Filter out any endpoints that are not in "AttachedShared" State. All running Windows pods with networking must be in this state. - filterMap := map[string]uint16{"State": HCN_ENDPOINT_STATE_ATTACHED_SHARING} - filter, err := json.Marshal(filterMap) - if err != nil { - return err + var filterMap map[string]uint16 + if !h.cfg.EnableStandalone { + filterMap = map[string]uint16{"State": HCN_ENDPOINT_STATE_ATTACHED_SHARING} + filter, err := json.Marshal(filterMap) + if err != nil { + return fmt.Errorf("failed to marshal filter map: %w", err) + } + h.endpointQuery.Filter = string(filter) + } + + if h.cfg.EnableStandalone { + if instance := enricher.StandaloneInstance(); instance != nil { + InitializeAdvancedMetrics() + h.l.Info("Metrics initialized") + + h.enricher = enricher.StandaloneInstance() + h.l.Info("Standalone enricher is enabled") + } else { + h.l.Warn("Standalone enricher is not initialized") + } } - h.endpointQuery.Filter = string(filter) h.l.Info("Exiting hnsstats Init...") return nil @@ -126,6 +143,13 @@ func pullHnsStats(ctx context.Context, h *hnsstats) error { mac := ep.MacAddress ip := ep.IpConfigurations[0].IpAddress + if h.cfg.EnableStandalone { + if err = h.enricher.PublishEvent(ip, enricher.AddEvent); err != nil { + h.l.Error("Failed to publish event", zap.String(zapIPField, ip), zap.Error(err)) + continue + } + } + if stats, err := hcsshim.GetHNSEndpointStats(id); err != nil { h.l.Error("Getting endpoint stats failed", zap.String(zapEndpointIDField, id), zap.Error(err)) } else { @@ -156,11 +180,66 @@ func pullHnsStats(ctx context.Context, h *hnsstats) error { notifyHnsStats(h, hnsStatsData) } } + + if h.cfg.EnableStandalone { + h.enricher.RemoveStaleEntries() + } } } } func notifyHnsStats(h *hnsstats, stats *HnsStatsData) { + if h.cfg.EnableStandalone { + labels := h.enricher.GetPodInfo(stats.IPAddress) + + if labels == nil { + h.l.Debug("No labels found for IP", zap.String(zapIPField, stats.IPAddress)) + return + } + + updateMetric(AdvForwardPacketsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsReceived, ingressLabel) + h.l.Debug("emitting packets received count metric", zap.Uint64(PacketsReceived, stats.hnscounters.PacketsReceived)) + updateMetric(AdvForwardPacketsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsSent, egressLabel) + h.l.Debug("emitting packets sent count metric", zap.Uint64(PacketsSent, stats.hnscounters.PacketsSent)) + updateMetric(AdvForwardBytesGauge, stats.IPAddress, labels, stats.hnscounters.BytesReceived, ingressLabel) + h.l.Debug("emitting bytes received count metric", zap.Uint64(BytesReceived, stats.hnscounters.BytesReceived)) + updateMetric(AdvForwardBytesGauge, stats.IPAddress, labels, stats.hnscounters.BytesSent, egressLabel) + h.l.Debug("emitting bytes sent count metric", zap.Uint64(BytesSent, stats.hnscounters.BytesSent)) + + updateMetric(AdvHNSStatsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsReceived, PacketsReceived) + updateMetric(AdvHNSStatsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsSent, PacketsSent) + + updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.hnscounters.DroppedPacketsOutgoing, utils.Endpoint, egressLabel) + updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.hnscounters.DroppedPacketsIncoming, utils.Endpoint, ingressLabel) + + if stats.vfpCounters == nil { + h.l.Debug("will not record some metrics since VFP port counters failed to be set") + return + } + + updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.vfpCounters.In.DropCounters.AclDropPacketCount, utils.AclRule, ingressLabel) + updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.vfpCounters.Out.DropCounters.AclDropPacketCount, utils.AclRule, egressLabel) + + updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.ResetCount, utils.ResetCount) + updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.ClosedFinCount, utils.ClosedFin) + updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.ResetSynCount, utils.ResetSyn) + updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.TcpHalfOpenTimeoutsCount, utils.TcpHalfOpenTimeouts) + updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.VerifiedCount, utils.Verified) + updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.TimedOutCount, utils.TimedOutCount) + updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.TimeWaitExpiredCount, utils.TimeWaitExpiredCount) + // TCP Flag counters + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.SynPacketCount, ingressLabel, utils.SYN) + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.SynAckPacketCount, ingressLabel, utils.SYNACK) + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.FinPacketCount, ingressLabel, utils.FIN) + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.RstPacketCount, ingressLabel, utils.RST) + + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.SynPacketCount, egressLabel, utils.SYN) + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.SynAckPacketCount, egressLabel, utils.SYNACK) + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.FinPacketCount, egressLabel, utils.FIN) + updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.RstPacketCount, egressLabel, utils.RST) + return + } + // hns signals metrics.ForwardPacketsGauge.WithLabelValues(ingressLabel).Set(float64(stats.hnscounters.PacketsReceived)) h.l.Debug("emitting packets received count metric", zap.Uint64(PacketsReceived, stats.hnscounters.PacketsReceived)) @@ -214,14 +293,19 @@ func (h *hnsstats) Start(ctx context.Context) error { return pullHnsStats(ctx, h) } -func (d *hnsstats) Stop() error { - d.l.Info("Entered hnsstats Stop...") - if d.state != start { - d.l.Info("plugin not started") +func (h *hnsstats) Stop() error { + h.l.Info("Entered hnsstats Stop...") + if h.state != start { + h.l.Info("plugin not started") return nil } - d.l.Info("Stopped listening for hnsstats event...") - d.state = stop - d.l.Info("Exiting hnsstats Stop...") + + if h.cfg.EnableStandalone { + cleanAdvMetrics() + } + + h.l.Info("Stopped listening for hnsstats event...") + h.state = stop + h.l.Info("Exiting hnsstats Stop...") return nil } diff --git a/pkg/plugin/hnsstats/types_windows.go b/pkg/plugin/hnsstats/types_windows.go index ab8511d5d3..ed11a4b5ce 100644 --- a/pkg/plugin/hnsstats/types_windows.go +++ b/pkg/plugin/hnsstats/types_windows.go @@ -10,7 +10,14 @@ import ( "github.com/Microsoft/hcsshim" "github.com/Microsoft/hcsshim/hcn" kcfg "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/microsoft/retina/pkg/enricher" + "github.com/microsoft/retina/pkg/exporter" "github.com/microsoft/retina/pkg/log" + "github.com/microsoft/retina/pkg/metrics" + m "github.com/microsoft/retina/pkg/module/metrics" + "github.com/microsoft/retina/pkg/utils" + "github.com/prometheus/client_golang/prometheus" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/metric" @@ -18,8 +25,8 @@ import ( ) const ( - name string = "hnsstats" - HnsStatsEvent string = "hnsstatscount" + name string = "hnsstats" + // From HNSStats API PacketsReceived string = "win_packets_recv_count" PacketsSent string = "win_packets_sent_count" @@ -67,12 +74,22 @@ const ( egressLabel = "egress" ) +var ( + AdvForwardPacketsGauge *prometheus.GaugeVec + AdvForwardBytesGauge *prometheus.GaugeVec + AdvHNSStatsGauge *prometheus.GaugeVec + AdvDroppedPacketsGauge *prometheus.GaugeVec + AdvTCPConnectionStatsGauge *prometheus.GaugeVec + AdvTCPFlagGauge *prometheus.GaugeVec +) + type hnsstats struct { cfg *kcfg.Config interval time.Duration state int l *log.ZapLogger endpointQuery hcn.HostComputeQuery + enricher *enricher.StandaloneEnricher } type HnsStatsData struct { @@ -147,3 +164,82 @@ func (h *HnsStatsData) String() string { return fmt.Sprintf("Endpoint ID: %s, Packets received: %d, Packets sent %d, Bytes sent %d, Bytes received %d", h.hnscounters.EndpointID, h.hnscounters.PacketsReceived, h.hnscounters.PacketsSent, h.hnscounters.BytesSent, h.hnscounters.BytesReceived) } + +func InitializeAdvancedMetrics() { + if exporter.AdvancedRegistry != nil { + cleanAdvMetrics() + exporter.ResetAdvancedMetricsRegistry() + } + + AdvForwardPacketsGauge = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + m.TotalCountName, + m.TotalCountDesc, + utils.Direction, + "ip", + "pod", + "namespace", + ) + AdvForwardBytesGauge = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + m.TotalBytesName, + m.TotalBytesDesc, + utils.Direction, + "ip", + "pod", + "namespace", + ) + AdvHNSStatsGauge = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + "adv_"+metrics.HNSStats, + metrics.HNSStatsDescription, + utils.Direction, + "ip", + "pod", + "namespace", + ) + AdvDroppedPacketsGauge = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + m.TotalDropCountName, + m.TotalDropCountDesc, + utils.Reason, + utils.Direction, + "ip", + "pod", + "namespace", + ) + // Bytes not available in HNS stats + AdvTCPConnectionStatsGauge = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + "adv_"+utils.TCPConnectionStatsName, + metrics.TCPConnectionStatsGaugeDescription, + utils.StatName, + "ip", + "pod", + "namespace", + ) + AdvTCPFlagGauge = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + m.TCPFlagsCountName, + m.TCPFlagsCountDesc, + utils.Direction, + utils.Flag, + "ip", + "pod", + "namespace", + ) +} + +func cleanAdvMetrics() { + exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvForwardPacketsGauge)) + exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvForwardBytesGauge)) + exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvHNSStatsGauge)) + exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvDroppedPacketsGauge)) + exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvTCPConnectionStatsGauge)) + exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvTCPFlagGauge)) +} + +func updateMetric(gauge *prometheus.GaugeVec, ip string, podInfo *cache.PodInfo, value uint64, labels ...string) { + labels = append(labels, ip, podInfo.Name, podInfo.Namespace) + gauge.WithLabelValues(labels...).Set(float64(value)) +} From 0dfedf61e0ffe034dba594a4a3320574ef308d7d Mon Sep 17 00:00:00 2001 From: beegiik Date: Thu, 14 Aug 2025 11:36:58 +0100 Subject: [PATCH 2/9] feat(standalone): Minor polishing --- pkg/enricher/ctrinfo/helper.go | 15 +++++++++++---- pkg/enricher/ctrinfo/helper_test.go | 6 ------ pkg/plugin/hnsstats/hnsstats_windows.go | 16 +++++++--------- 3 files changed, 18 insertions(+), 19 deletions(-) diff --git a/pkg/enricher/ctrinfo/helper.go b/pkg/enricher/ctrinfo/helper.go index 044604cf2b..be0d8dc72d 100644 --- a/pkg/enricher/ctrinfo/helper.go +++ b/pkg/enricher/ctrinfo/helper.go @@ -7,6 +7,7 @@ import ( "bytes" "context" "encoding/json" + "errors" "fmt" "os/exec" "strings" @@ -33,12 +34,18 @@ type Network struct { IP string `json:"ip"` } -var crictlCommand = runCommand +var ( + crictlCommand = runCommand + + errGetPods = errors.New("failed to get running pods") + errInspectPod = errors.New("failed to inspect pod information") + errJSONRead = errors.New("error unmarshalling JSON") +) func GetPodInfo(ip string) (*cache.PodInfo, error) { runningPods, err := crictlCommand("cmd", "/c", "crictl", "pods", "-q") if err != nil { - return nil, fmt.Errorf("failed to get running pods: %w", err) + return nil, fmt.Errorf("%w: %v", errGetPods, err) } podIDs := strings.Split(strings.TrimSpace(runningPods), "\n") @@ -49,12 +56,12 @@ func GetPodInfo(ip string) (*cache.PodInfo, error) { podSpec, err := crictlCommand("cmd", "/c", "crictl", "inspectp", podID) if err != nil { - return nil, fmt.Errorf("failed to inspect pod information: %w", err) + return nil, fmt.Errorf("%w: %v", errInspectPod, err) } var spec PodSpec if err := json.Unmarshal([]byte(podSpec), &spec); err != nil { - return nil, fmt.Errorf("error unmarshalling JSON: %w", err) + return nil, fmt.Errorf("%w: %v", errJSONRead, err) } if spec.Status.Network.IP == ip { diff --git a/pkg/enricher/ctrinfo/helper_test.go b/pkg/enricher/ctrinfo/helper_test.go index 9dbe747894..d0ab6a44c3 100644 --- a/pkg/enricher/ctrinfo/helper_test.go +++ b/pkg/enricher/ctrinfo/helper_test.go @@ -13,12 +13,6 @@ import ( "sigs.k8s.io/kind/pkg/errors" ) -var ( - errGetPods = errors.New("Failed to get running pods") - errInspectPod = errors.New("Failed to inspect pod information") - errJSONRead = errors.New("unexpected end of JSON input") -) - func TestGetPodInfo(t *testing.T) { invalidJSONPath := "invalid_pod_spec.json" invalidJSONContent := `{"status": {"metadata": {"name": "retina-pod", "namespace": "retina-namespace"}` diff --git a/pkg/plugin/hnsstats/hnsstats_windows.go b/pkg/plugin/hnsstats/hnsstats_windows.go index 08444679b4..5a9ff3bae4 100644 --- a/pkg/plugin/hnsstats/hnsstats_windows.go +++ b/pkg/plugin/hnsstats/hnsstats_windows.go @@ -81,15 +81,6 @@ func (h *hnsstats) Init() error { } // Filter out any endpoints that are not in "AttachedShared" State. All running Windows pods with networking must be in this state. var filterMap map[string]uint16 - if !h.cfg.EnableStandalone { - filterMap = map[string]uint16{"State": HCN_ENDPOINT_STATE_ATTACHED_SHARING} - filter, err := json.Marshal(filterMap) - if err != nil { - return fmt.Errorf("failed to marshal filter map: %w", err) - } - h.endpointQuery.Filter = string(filter) - } - if h.cfg.EnableStandalone { if instance := enricher.StandaloneInstance(); instance != nil { InitializeAdvancedMetrics() @@ -100,6 +91,13 @@ func (h *hnsstats) Init() error { } else { h.l.Warn("Standalone enricher is not initialized") } + } else { + filterMap = map[string]uint16{"State": HCN_ENDPOINT_STATE_ATTACHED_SHARING} + filter, err := json.Marshal(filterMap) + if err != nil { + return fmt.Errorf("failed to marshal filter map: %w", err) + } + h.endpointQuery.Filter = string(filter) } h.l.Info("Exiting hnsstats Init...") From 751bc3c99cdede56271c0a081576a10c7883b516 Mon Sep 17 00:00:00 2001 From: beegiik Date: Fri, 29 Aug 2025 12:19:02 +0100 Subject: [PATCH 3/9] feat(standalone): Update parsing of events to use flows and update existing architecture to support standalone --- cmd/standalone/daemon.go | 17 +- cmd/standard/daemon.go | 2 +- go.mod | 4 +- pkg/controllers/cache/standalone/cache.go | 111 + .../cache/standalone/cache_test.go | 163 + pkg/controllers/cache/standalone_cache.go | 95 - .../cache/standalone_cache_test.go | 164 - .../daemon/standalone/controller.go | 116 + .../daemon/standalone/controller_test.go | 69 + .../daemon/standalone/utils/ctrinfo.go} | 35 +- .../daemon/standalone/utils/ctrinfo_test.go} | 85 +- .../standalone/utils}/mock_podSpec.json | 0 .../daemon/standalone/utils/mock_source.go | 56 + .../standalone/utils}/mock_statefile.json | 0 .../daemon/standalone/utils/statefile.go} | 29 +- .../daemon/standalone/utils/statefile_test.go | 107 + .../daemon/standalone/utils/types.go | 11 + pkg/enricher/{standard.go => enricher.go} | 49 +- .../{standard_test.go => enricher_test.go} | 133 +- pkg/enricher/standalone.go | 151 - pkg/enricher/standalone_test.go | 156 - pkg/enricher/statefile/helper_test.go | 103 - .../controllermanager/controllermanager.go | 2 +- pkg/module/metrics/basemetricsobject.go | 2 +- pkg/module/metrics/dns.go | 1 + pkg/module/metrics/drops.go | 45 +- pkg/module/metrics/drops_test.go | 98 +- pkg/module/metrics/forward.go | 46 +- pkg/module/metrics/forward_test.go | 83 +- pkg/module/metrics/hns.go | 91 + pkg/module/metrics/hns_test.go | 79 + pkg/module/metrics/metrics_module.go | 20 +- .../metrics/standalone/metrics_module.go | 146 + .../metrics/standalone/metrics_module_test.go | 170 + pkg/module/metrics/tcp.go | 95 + pkg/module/metrics/tcp_test.go | 106 + pkg/module/metrics/tcpflags.go | 57 +- pkg/module/metrics/tcpflags_test.go | 114 +- pkg/module/metrics/types.go | 22 +- .../ciliumeventobserver_linux_test.go | 2 +- pkg/plugin/dns/dns_linux_test.go | 2 +- pkg/plugin/hnsstats/hnsstats_windows.go | 105 +- pkg/plugin/hnsstats/types_windows.go | 86 +- pkg/utils/flow_utils.go | 23 + pkg/utils/metadata_linux.pb.go | 1021 +++++- pkg/utils/metadata_linux.proto | 59 + pkg/utils/metadata_windows.pb.go | 2735 +++++++++++------ pkg/utils/metadata_windows.proto | 59 + test/enricher/main_linux.go | 2 +- test/plugin/dns/main_linux.go | 2 +- 50 files changed, 4988 insertions(+), 1941 deletions(-) create mode 100644 pkg/controllers/cache/standalone/cache.go create mode 100644 pkg/controllers/cache/standalone/cache_test.go delete mode 100644 pkg/controllers/cache/standalone_cache.go delete mode 100644 pkg/controllers/cache/standalone_cache_test.go create mode 100644 pkg/controllers/daemon/standalone/controller.go create mode 100644 pkg/controllers/daemon/standalone/controller_test.go rename pkg/{enricher/ctrinfo/helper.go => controllers/daemon/standalone/utils/ctrinfo.go} (69%) rename pkg/{enricher/ctrinfo/helper_test.go => controllers/daemon/standalone/utils/ctrinfo_test.go} (55%) rename pkg/{enricher/ctrinfo => controllers/daemon/standalone/utils}/mock_podSpec.json (100%) create mode 100644 pkg/controllers/daemon/standalone/utils/mock_source.go rename pkg/{enricher/statefile => controllers/daemon/standalone/utils}/mock_statefile.json (100%) rename pkg/{enricher/statefile/helper.go => controllers/daemon/standalone/utils/statefile.go} (72%) create mode 100644 pkg/controllers/daemon/standalone/utils/statefile_test.go create mode 100644 pkg/controllers/daemon/standalone/utils/types.go rename pkg/enricher/{standard.go => enricher.go} (75%) rename pkg/enricher/{standard_test.go => enricher_test.go} (59%) delete mode 100644 pkg/enricher/standalone.go delete mode 100644 pkg/enricher/standalone_test.go delete mode 100644 pkg/enricher/statefile/helper_test.go create mode 100644 pkg/module/metrics/hns.go create mode 100644 pkg/module/metrics/hns_test.go create mode 100644 pkg/module/metrics/standalone/metrics_module.go create mode 100644 pkg/module/metrics/standalone/metrics_module_test.go create mode 100644 pkg/module/metrics/tcp.go create mode 100644 pkg/module/metrics/tcp_test.go diff --git a/cmd/standalone/daemon.go b/cmd/standalone/daemon.go index fb4a99d73d..d359e4f953 100644 --- a/cmd/standalone/daemon.go +++ b/cmd/standalone/daemon.go @@ -10,12 +10,15 @@ import ( "github.com/microsoft/retina/cmd/telemetry" "github.com/microsoft/retina/pkg/enricher" "github.com/microsoft/retina/pkg/log" + "github.com/microsoft/retina/pkg/metrics" "go.uber.org/zap" ctrl "sigs.k8s.io/controller-runtime" "github.com/microsoft/retina/pkg/config" - "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/microsoft/retina/pkg/controllers/cache/standalone" + sd "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" ) const TTL = 3 * time.Minute @@ -34,17 +37,23 @@ func (d *Daemon) Start(zl *log.ZapLogger) error { zl.Info("Starting Standalone Retina daemon") mainLogger := zl.Named("standalone-daemon").Sugar() + metrics.InitializeMetrics() + tel, err := telemetry.InitializeTelemetryClient(nil, d.config, mainLogger) if err != nil { return fmt.Errorf("failed to initialize telemetry client: %w", err) } - ctx := ctrl.SetupSignalHandler() - c := cache.NewStandaloneCache(TTL) - enrich := enricher.NewStandaloneEnricher(ctx, c, d.config) + cache := standalone.NewCache() + enrich := enricher.New(ctx, cache, d.config.EnableStandalone) enrich.Run() + metricsModule := sm.InitModule(ctx, enrich) + + controller := sd.New(d.config, cache, metricsModule) + go controller.Run(ctx) + // pod level needs to be disabled controllerMgr, err := cm.NewControllerManager(d.config, nil, tel) if err != nil { diff --git a/cmd/standard/daemon.go b/cmd/standard/daemon.go index 43c8003043..8ef4daa0dd 100644 --- a/cmd/standard/daemon.go +++ b/cmd/standard/daemon.go @@ -191,7 +191,7 @@ func (d *Daemon) Start(zl *log.ZapLogger) error { if d.config.EnablePodLevel { pubSub := pubsub.New() controllerCache := controllercache.New(pubSub) - enrich := enricher.New(ctx, controllerCache) + enrich := enricher.New(ctx, controllerCache, d.config.EnableStandalone) //nolint:govet // shadowing this err is fine fm, err := filtermanager.Init(5) //nolint:gomnd // defaults if err != nil { diff --git a/go.mod b/go.mod index 4b7f4c8433..5ee98129bd 100644 --- a/go.mod +++ b/go.mod @@ -220,7 +220,7 @@ require ( google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a // indirect gopkg.in/inf.v0 v0.9.1 // indirect k8s.io/apiserver v0.32.3 // indirect - k8s.io/component-base v0.32.3 // indirect + k8s.io/component-base v0.32.3 k8s.io/cri-api v0.30.1 // indirect oras.land/oras-go v1.2.5 // indirect sigs.k8s.io/kustomize/api v0.18.0 // indirect @@ -272,6 +272,7 @@ require ( github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2 github.com/Microsoft/hcsshim v0.13.0 github.com/Sytten/logrus-zap-hook v0.1.0 + github.com/alecthomas/assert/v2 v2.11.0 github.com/aws/aws-sdk-go-v2 v1.38.0 github.com/aws/aws-sdk-go-v2/config v1.30.2 github.com/aws/aws-sdk-go-v2/credentials v1.18.2 @@ -371,6 +372,7 @@ require ( github.com/OpenPeeDeeP/depguard/v2 v2.2.1 // indirect github.com/ProtonMail/go-crypto v1.1.3 // indirect github.com/alecthomas/go-check-sumtype v0.3.1 // indirect + github.com/alecthomas/repr v0.4.0 // indirect github.com/alessio/shellescape v1.4.1 // indirect github.com/alexkohler/nakedret/v2 v2.0.5 // indirect github.com/alexkohler/prealloc v1.0.0 // indirect diff --git a/pkg/controllers/cache/standalone/cache.go b/pkg/controllers/cache/standalone/cache.go new file mode 100644 index 0000000000..a13e7a6b67 --- /dev/null +++ b/pkg/controllers/cache/standalone/cache.go @@ -0,0 +1,111 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package standalone + +import ( + "net" + "sync" + + "github.com/microsoft/retina/pkg/common" + "github.com/microsoft/retina/pkg/log" + "go.uber.org/zap" +) + +type Cache struct { + sync.RWMutex + l *log.ZapLogger + // ipToEndpoint is a map of IP addresses to RetinaEndpoints (namespace/name) + ipToEndpoint map[string]*common.RetinaEndpoint +} + +// NewCache returns a new instance of Cache +func NewCache() *Cache { + c := &Cache{ + l: log.Logger().Named("Cache"), + ipToEndpoint: make(map[string]*common.RetinaEndpoint), + } + return c +} + +// GetAllIPs returns a list of all IPs in the cache +func (c *Cache) GetAllIPs() []string { + c.RLock() + defer c.RUnlock() + + ips := make([]string, 0, len(c.ipToEndpoint)) + for ip := range c.ipToEndpoint { + ips = append(ips, ip) + } + return ips +} + +// GetPodByIP returns the RetinaEndpoint for the given IP +func (c *Cache) GetPodByIP(ip string) *common.RetinaEndpoint { + c.RLock() + defer c.RUnlock() + return c.ipToEndpoint[ip] +} + +// UpdateRetinaEndpoint updates the cache with the given retina endpoint +func (c *Cache) UpdateRetinaEndpoint(ep *common.RetinaEndpoint) error { + c.Lock() + defer c.Unlock() + return c.updateEndpoint(ep) +} + +// updateEndpoint updates the cache if there is a new retina endpoint +func (c *Cache) updateEndpoint(ep *common.RetinaEndpoint) error { + ip, err := ep.PrimaryIP() + if err != nil { + c.l.Error("error getting IP for endpoint", zap.Error(err)) + return err + } + + if pod, exists := c.ipToEndpoint[ip]; exists { + if pod.Name() == ep.Name() && pod.Namespace() == ep.Namespace() { + return nil + } + } + c.ipToEndpoint[ip] = ep + c.l.Info("Added RetinaEndpoint in cache", zap.String("ip", ip), zap.String("namespace", ep.Namespace()), zap.String("name", ep.Name())) + return nil +} + +// DeleteRetinaEndpoint deletes the given retina endpoint from the cache +func (c *Cache) DeleteRetinaEndpoint(epKey string) error { + c.Lock() + defer c.Unlock() + return c.deleteEndpoint(epKey) +} + +// deleteEndpoint deletes the given retina endpoint from the cache +func (c *Cache) deleteEndpoint(epKey string) error { + if ep, exists := c.ipToEndpoint[epKey]; exists { + delete(c.ipToEndpoint, epKey) + c.l.Info("Deleted RetinaEndpoint from cache", zap.String("ip", epKey), zap.String("namespace", ep.Namespace()), zap.String("name", ep.Name())) + return nil + } + return nil +} + +func (c *Cache) Clear() { + c.Lock() + defer c.Unlock() + c.ipToEndpoint = make(map[string]*common.RetinaEndpoint) + c.l.Info("Cleared all RetinaEndpoints from cache") +} + +// No op +func (c *Cache) GetSvcByIP(ip string) *common.RetinaSvc { return nil } +func (c *Cache) GetNodeByIP(ip string) *common.RetinaNode { return nil } +func (c *Cache) GetObjByIP(ip string) interface{} { return nil } +func (c *Cache) GetIPsByNamespace(ns string) []net.IP { return nil } +func (c *Cache) GetAnnotatedNamespaces() []string { return nil } + +func (c *Cache) UpdateRetinaSvc(svc *common.RetinaSvc) error { return nil } +func (c *Cache) DeleteRetinaSvc(key string) error { return nil } +func (c *Cache) UpdateRetinaNode(node *common.RetinaNode) error { return nil } +func (c *Cache) DeleteRetinaNode(name string) error { return nil } +func (c *Cache) AddAnnotatedNamespace(ns string) {} +func (c *Cache) DeleteAnnotatedNamespace(ns string) {} diff --git a/pkg/controllers/cache/standalone/cache_test.go b/pkg/controllers/cache/standalone/cache_test.go new file mode 100644 index 0000000000..0bdc3e7ab3 --- /dev/null +++ b/pkg/controllers/cache/standalone/cache_test.go @@ -0,0 +1,163 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package standalone + +import ( + "net" + "testing" + + "github.com/microsoft/retina/pkg/common" + "github.com/microsoft/retina/pkg/log" + "github.com/stretchr/testify/require" +) + +var ( + ep1 = common.NewRetinaEndpoint("pod1", "ns1", &common.IPAddresses{IPv4: net.ParseIP("10.0.0.1")}) + ep2 = common.NewRetinaEndpoint("pod2", "ns2", &common.IPAddresses{IPv4: net.ParseIP("10.0.0.1")}) + ep3 = common.NewRetinaEndpoint("pod1", "ns1", &common.IPAddresses{IPv4: net.ParseIP("10.0.0.1")}) +) + +func TestCacheAddEndpoint(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + c := NewCache() + + tests := []struct { + name string + endpoint *common.RetinaEndpoint + expectedPod string + expectedNS string + }{ + { + name: "Add new endpoint", + endpoint: ep1, + expectedPod: ep1.Name(), + expectedNS: ep1.Namespace(), + }, + { + name: "Add identical endpoint", + endpoint: ep3, + expectedPod: ep1.Name(), + expectedNS: ep1.Namespace(), + }, + { + name: "Update endpoint info for same IP", + endpoint: ep2, + expectedPod: ep2.Name(), + expectedNS: ep2.Namespace(), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c.UpdateRetinaEndpoint(tt.endpoint) + + ip, err := tt.endpoint.PrimaryIP() + require.NoError(t, err) + + got := c.GetPodByIP(ip) + require.NotNil(t, got, "Expected retina endpoint, got nil") + require.Equal(t, tt.expectedPod, got.Name()) + require.Equal(t, tt.expectedNS, got.Namespace()) + }) + } +} + +func TestCacheDeleteEndpoint(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + c := NewCache() + ip, err := ep1.PrimaryIP() + if err != nil { + t.Fatalf("failed to get IP for endpoint: %v", err) + } + + tests := []struct { + name string + setup func() + ip string + expectedEndpoint *common.RetinaEndpoint + }{ + { + name: "Delete existing endpoint", + setup: func() { + c.UpdateRetinaEndpoint(ep1) + }, + ip: ip, + expectedEndpoint: nil, + }, + { + name: "Delete non-existing pod (no-op)", + setup: func() {}, + ip: "10.0.0.2", + expectedEndpoint: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.setup() + c.DeleteRetinaEndpoint(tt.ip) + + got := c.GetPodByIP(tt.ip) + require.Equal(t, tt.expectedEndpoint, got) + }) + } +} + +func TestCacheGetAllIPs(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + c := NewCache() + ep4 := common.NewRetinaEndpoint("pod4", "ns4", &common.IPAddresses{IPv4: net.ParseIP("10.0.0.4")}) + + tests := []struct { + name string + actions func() + wantIPs []string + }{ + { + name: "Add ep1 and ep2", + actions: func() { + _ = c.UpdateRetinaEndpoint(ep1) + _ = c.UpdateRetinaEndpoint(ep2) + }, + wantIPs: []string{"10.0.0.1"}, + }, + { + name: "Add ep4", + actions: func() { + _ = c.UpdateRetinaEndpoint(ep4) + }, + wantIPs: []string{"10.0.0.1", "10.0.0.4"}, + }, + { + name: "Delete ep1", + actions: func() { + ip1, _ := ep1.PrimaryIP() + _ = c.DeleteRetinaEndpoint(ip1) + }, + wantIPs: []string{"10.0.0.4"}, + }, + { + name: "Delete ep4", + actions: func() { + ip4, _ := ep4.PrimaryIP() + _ = c.DeleteRetinaEndpoint(ip4) + }, + wantIPs: []string{}, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tt.actions() + ips := c.GetAllIPs() + require.ElementsMatch(t, tt.wantIPs, ips, "IPs mismatch for test: %s", tt.name) + }) + } +} diff --git a/pkg/controllers/cache/standalone_cache.go b/pkg/controllers/cache/standalone_cache.go deleted file mode 100644 index 5724275021..0000000000 --- a/pkg/controllers/cache/standalone_cache.go +++ /dev/null @@ -1,95 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. - -package cache - -import ( - "sync" - "time" - - "github.com/microsoft/retina/pkg/log" - "go.uber.org/zap" -) - -type PodInfo struct { - Name string - Namespace string - LastUpdate time.Time -} - -type StandaloneCache struct { - rwMutex sync.RWMutex - l *log.ZapLogger - ipToPod map[string]*PodInfo - ttl time.Duration -} - -func NewStandaloneCache(ttl time.Duration) *StandaloneCache { - return &StandaloneCache{ - l: log.Logger().Named(string("standalone-cache")), - ipToPod: make(map[string]*PodInfo), - ttl: ttl, - } -} - -func (c *StandaloneCache) GetPod(ip string) *PodInfo { - c.rwMutex.RLock() - defer c.rwMutex.RUnlock() - - if pod, exists := c.ipToPod[ip]; exists { - return pod - } - return nil -} - -func (c *StandaloneCache) Update(ip string, podInfo *PodInfo) { - if podInfo != nil { - c.addPod(ip, podInfo.Name, podInfo.Namespace) - } else { - c.deletePod(ip) - } -} - -func (c *StandaloneCache) ForEach(f func(ip string, podInfo *PodInfo)) { - c.rwMutex.RLock() - defer c.rwMutex.RUnlock() - - for ip, podInfo := range c.ipToPod { - f(ip, podInfo) - } -} - -func (c *StandaloneCache) TTL() time.Duration { - return c.ttl -} - -func (c *StandaloneCache) addPod(ip, name, namespace string) { - c.rwMutex.Lock() - defer c.rwMutex.Unlock() - - existingPod, exists := c.ipToPod[ip] - newPod := &PodInfo{Name: name, Namespace: namespace, LastUpdate: time.Now()} - - // Skip adding element if identical - if exists && existingPod.isEqual(newPod) { - existingPod.LastUpdate = time.Now() - return - } - - c.ipToPod[ip] = newPod - c.l.Info("Added pod to cache", zap.String("ip", ip), zap.String("pod", name), zap.String("namespace", namespace)) -} - -func (c *StandaloneCache) deletePod(ip string) { - c.rwMutex.Lock() - defer c.rwMutex.Unlock() - - if podInfo, exists := c.ipToPod[ip]; exists { - delete(c.ipToPod, ip) - c.l.Info("Deleted pod from cache", zap.String("ip", ip), zap.String("pod", podInfo.Name), zap.String("namespace", podInfo.Namespace)) - } -} - -func (c *PodInfo) isEqual(other *PodInfo) bool { - return c.Name == other.Name && c.Namespace == other.Namespace -} diff --git a/pkg/controllers/cache/standalone_cache_test.go b/pkg/controllers/cache/standalone_cache_test.go deleted file mode 100644 index 7a9737a738..0000000000 --- a/pkg/controllers/cache/standalone_cache_test.go +++ /dev/null @@ -1,164 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. - -package cache - -import ( - "testing" - "time" - - "github.com/microsoft/retina/pkg/log" - "github.com/stretchr/testify/require" -) - -var ( - ip = "10.0.0.1" - p1 = &PodInfo{Name: "pod1", Namespace: "ns1"} - ttl = 3 * time.Minute -) - -func TestCacheAddPod(t *testing.T) { - if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { - t.Errorf("Error setting up logger: %s", err) - } - c := NewStandaloneCache(ttl) - - p2 := &PodInfo{Name: "pod2", Namespace: "ns2"} - p3 := &PodInfo{Name: "pod1", Namespace: "ns1"} - - tests := []struct { - name string - ip string - pod string - namespace string - expectedPod string - expectedNS string - }{ - { - name: "Add new pod", - ip: ip, - pod: p1.Name, - namespace: p1.Namespace, - expectedPod: p1.Name, - expectedNS: p1.Namespace, - }, - { - name: "Add identical pod", - ip: ip, - pod: p3.Name, - namespace: p3.Namespace, - expectedPod: p1.Name, - expectedNS: p1.Namespace, - }, - { - name: "Update pod info for same IP", - ip: ip, - pod: p2.Name, - namespace: p2.Namespace, - expectedPod: p2.Name, - expectedNS: p2.Namespace, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - c.addPod(tt.ip, tt.pod, tt.namespace) - - got := c.GetPod(tt.ip) - require.NotNil(t, got, "Expected pod info, got nil") - require.Equal(t, tt.expectedPod, got.Name) - require.Equal(t, tt.expectedNS, got.Namespace) - }) - } -} - -func TestCacheDeletePod(t *testing.T) { - if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { - t.Errorf("Error setting up logger: %s", err) - } - c := NewStandaloneCache(ttl) - - tests := []struct { - name string - setup func() - ip string - expectedPodInfo *PodInfo - }{ - { - name: "Delete existing pod", - setup: func() { - c.addPod(ip, p1.Name, p1.Namespace) - }, - ip: ip, - expectedPodInfo: nil, - }, - { - name: "Delete non-existing pod (no-op)", - setup: func() {}, - ip: "10.0.0.2", - expectedPodInfo: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.setup() - c.deletePod(tt.ip) - - got := c.GetPod(tt.ip) - require.Equal(t, tt.expectedPodInfo, got) - }) - } -} - -func TestCacheUpdate(t *testing.T) { - if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { - t.Errorf("Error setting up logger: %s", err) - } - c := NewStandaloneCache(ttl) - - tests := []struct { - name string - ip string - podInfo *PodInfo - expectedPodInfo *PodInfo - }{ - { - name: "Add Pod", - ip: ip, - podInfo: p1, - expectedPodInfo: p1, - }, - { - name: "Delete Pod", - ip: ip, - podInfo: nil, - expectedPodInfo: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - c.Update(tt.ip, tt.podInfo) - - got := c.GetPod(tt.ip) - if tt.expectedPodInfo == nil { - require.Nil(t, got, "Expected nil pod info, got %v", got) - } else { - require.NotNil(t, got != nil, "Expected pod info, got nil") - require.Equal(t, tt.expectedPodInfo.Name, got.Name) - require.Equal(t, tt.expectedPodInfo.Namespace, got.Namespace) - } - }) - } -} - -func TestCacheTTL(t *testing.T) { - if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { - t.Errorf("Error setting up logger: %s", err) - } - c := NewStandaloneCache(ttl) - - cacheTime := c.TTL() - require.Equal(t, cacheTime, ttl) -} diff --git a/pkg/controllers/daemon/standalone/controller.go b/pkg/controllers/daemon/standalone/controller.go new file mode 100644 index 0000000000..8070cdd446 --- /dev/null +++ b/pkg/controllers/daemon/standalone/controller.go @@ -0,0 +1,116 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package standalone + +import ( + "context" + "time" + + "github.com/microsoft/retina/pkg/common" + kcfg "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/controllers/cache/standalone" + "github.com/microsoft/retina/pkg/controllers/daemon/standalone/utils" + sm "github.com/microsoft/retina/pkg/module/metrics/standalone" + + "github.com/microsoft/retina/pkg/log" + + "go.uber.org/zap" +) + +type StandaloneController struct { + // interface for fetching endpoint information + source utils.Source + // cache to hold retina endpoints + cache *standalone.Cache + + metricsModule *sm.Module + config *kcfg.Config + l *log.ZapLogger +} + +func New(config *kcfg.Config, cache *standalone.Cache, metricsModule *sm.Module) *StandaloneController { + var source utils.Source + + if config.EnableCrictl { + source = &utils.CtrinfoSource{} + } else { + source = &utils.StatefileSource{} + } + + return &StandaloneController{ + source: source, + cache: cache, + config: config, + metricsModule: metricsModule, + l: log.Logger().Named(string("StandaloneController")), + } +} + +// Reconcile syncs the state of the endpoints with the desired state +func (sc *StandaloneController) Reconcile(ctx context.Context) error { + sc.l.Info("Starting standalone reconciliation") + + srcEndpoints, err := sc.source.GetAllEndpoints() + if err != nil { + sc.l.Error("Failed to get all endpoints", zap.Error(err)) + return err + } + + srcIPs := make(map[string]*common.RetinaEndpoint, len(srcEndpoints)) + for _, ep := range srcEndpoints { + ip, err := ep.PrimaryIP() + if err != nil { + continue + } + if ip == "" { + continue + } + srcIPs[ip] = ep + } + + cachedIPs := sc.cache.GetAllIPs() + + for _, ip := range cachedIPs { + if _, exists := srcIPs[ip]; !exists { + sc.cache.DeleteRetinaEndpoint(ip) + // sc.metricsModule.RemoveSeries(ip) + } + } + + for ip, ep := range srcIPs { + if err := sc.cache.UpdateRetinaEndpoint(ep); err != nil { + sc.l.Error("Failed to update retina endpoint", zap.String("ip", ip), zap.Error(err)) + return err + } + } + sc.metricsModule.Reconcile(ctx) + + sc.l.Info("Standalone reconciliation completed") + return nil +} + +func (sc *StandaloneController) Run(ctx context.Context) { + sc.l.Info("Starting Standalone Controller") + + ticker := time.NewTicker(sc.config.MetricsInterval / 2) + defer ticker.Stop() + + for { + select { + case <-ctx.Done(): + sc.Stop() + return + case <-ticker.C: + if err := sc.Reconcile(ctx); err != nil { + sc.l.Error("Failed to reconcile", zap.Error(err)) + } + } + } +} + +func (sc *StandaloneController) Stop() { + sc.l.Info("Stopping Standalone Controller") + sc.cache.Clear() + sc.metricsModule.Clear() +} diff --git a/pkg/controllers/daemon/standalone/controller_test.go b/pkg/controllers/daemon/standalone/controller_test.go new file mode 100644 index 0000000000..f1a9dc240c --- /dev/null +++ b/pkg/controllers/daemon/standalone/controller_test.go @@ -0,0 +1,69 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package standalone + +import ( + "context" + "net" + "testing" + + "github.com/microsoft/retina/pkg/common" + kcfg "github.com/microsoft/retina/pkg/config" + "github.com/microsoft/retina/pkg/controllers/cache/standalone" + utils "github.com/microsoft/retina/pkg/controllers/daemon/standalone/utils" + "github.com/microsoft/retina/pkg/log" + sm "github.com/microsoft/retina/pkg/module/metrics/standalone" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" +) + +func TestStandaloneController_Reconcile(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + // Setup logger + _, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + ctx := context.Background() + + // Mock source + mockSource := utils.NewMockSource(ctrl) + + // Cache + cache := standalone.NewCache() + + // Metrics module + metricsModule := sm.InitModule(ctx, nil) + + // Prepopulate cache with an endpoint to simulate deletion + oldEndpoint := common.NewRetinaEndpoint("old-pod", "default", &common.IPAddresses{IPv4: net.ParseIP("1.1.1.2")}) + require.NoError(t, cache.UpdateRetinaEndpoint(oldEndpoint)) + + // Endpoint returned by the source + newEndpoint := common.NewRetinaEndpoint("new-pod", "default", &common.IPAddresses{IPv4: net.ParseIP("1.1.1.1")}) + mockSource.EXPECT().GetAllEndpoints().Return([]*common.RetinaEndpoint{newEndpoint}, nil) + + // Setup controller + cfg := &kcfg.Config{MetricsInterval: 1, EnableCrictl: false} + controller := New(cfg, cache, metricsModule) + controller.source = mockSource // inject mock source + + // Run Reconcile + err = controller.Reconcile(ctx) + assert.NoError(t, err) + + // Validate cache updates + cachedIPs := cache.GetAllIPs() + assert.Len(t, cachedIPs, 1, "only new endpoint should remain in cache") + assert.Contains(t, cachedIPs, "1.1.1.1") + + // Validate old endpoint removed + assert.NotContains(t, cachedIPs, "1.1.1.2") + + controller.Stop() + assert.Equal(t, len(controller.cache.GetAllIPs()), 0) +} diff --git a/pkg/enricher/ctrinfo/helper.go b/pkg/controllers/daemon/standalone/utils/ctrinfo.go similarity index 69% rename from pkg/enricher/ctrinfo/helper.go rename to pkg/controllers/daemon/standalone/utils/ctrinfo.go index be0d8dc72d..86e47bf738 100644 --- a/pkg/enricher/ctrinfo/helper.go +++ b/pkg/controllers/daemon/standalone/utils/ctrinfo.go @@ -1,7 +1,7 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT license. -package ctrinfo +package utils import ( "bytes" @@ -9,20 +9,23 @@ import ( "encoding/json" "errors" "fmt" + "net" "os/exec" "strings" "time" - "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/microsoft/retina/pkg/common" ) +type CtrinfoSource struct{} + type PodSpec struct { Status Status `json:"status"` } type Status struct { - Metadata Metadata `json:"metadata"` - Network Network `json:"network"` + Metadata Metadata `json:"metadata"` + Network PodNetwork `json:"network"` } type Metadata struct { @@ -30,7 +33,7 @@ type Metadata struct { Namespace string `json:"namespace"` } -type Network struct { +type PodNetwork struct { IP string `json:"ip"` } @@ -42,13 +45,14 @@ var ( errJSONRead = errors.New("error unmarshalling JSON") ) -func GetPodInfo(ip string) (*cache.PodInfo, error) { +func (cs *CtrinfoSource) GetAllEndpoints() ([]*common.RetinaEndpoint, error) { runningPods, err := crictlCommand("cmd", "/c", "crictl", "pods", "-q") if err != nil { - return nil, fmt.Errorf("%w: %v", errGetPods, err) + return nil, fmt.Errorf("%v: %v", errGetPods, err) } podIDs := strings.Split(strings.TrimSpace(runningPods), "\n") + endpoints := []*common.RetinaEndpoint{} for _, podID := range podIDs { if podID == "" { continue @@ -64,15 +68,20 @@ func GetPodInfo(ip string) (*cache.PodInfo, error) { return nil, fmt.Errorf("%w: %v", errJSONRead, err) } - if spec.Status.Network.IP == ip { - return &cache.PodInfo{ - Name: spec.Status.Metadata.Name, - Namespace: spec.Status.Metadata.Namespace, - }, nil + ip := net.ParseIP(spec.Status.Network.IP) + if ip == nil { + // Skip pods with invalid or empty IPs + continue } + + endpoints = append(endpoints, common.NewRetinaEndpoint( + spec.Status.Metadata.Name, + spec.Status.Metadata.Namespace, + common.NewIPAddress(ip, nil), + )) } - return nil, nil + return endpoints, nil } func runCommand(command string, args ...string) (string, error) { diff --git a/pkg/enricher/ctrinfo/helper_test.go b/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go similarity index 55% rename from pkg/enricher/ctrinfo/helper_test.go rename to pkg/controllers/daemon/standalone/utils/ctrinfo_test.go index d0ab6a44c3..8e07521356 100644 --- a/pkg/enricher/ctrinfo/helper_test.go +++ b/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go @@ -1,19 +1,20 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT license. -package ctrinfo +package utils import ( + "net" "os" "strings" "testing" - "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/microsoft/retina/pkg/common" "github.com/stretchr/testify/require" "sigs.k8s.io/kind/pkg/errors" ) -func TestGetPodInfo(t *testing.T) { +func TestCtrinfoGetAllEndpoints(t *testing.T) { invalidJSONPath := "invalid_pod_spec.json" invalidJSONContent := `{"status": {"metadata": {"name": "retina-pod", "namespace": "retina-namespace"}` @@ -21,59 +22,57 @@ func TestGetPodInfo(t *testing.T) { require.NoError(t, err, "failed to create invalid JSON file") defer os.Remove(invalidJSONPath) + cs := &CtrinfoSource{} + tests := []struct { - name string - ip string - podCmdOutput string - inspectCmdOutput string - getPodsErr error - inspectPodErr error - expectedErr error - expectedPodInfo *cache.PodInfo + name string + podCmdOutput string + inspectCmdOutput string + getPodsErr error + inspectPodErr error + expectedErr error + expectedCount int + expectedRetinaEndpoint *common.RetinaEndpoint }{ { - name: "IP found in list of running pods", - ip: "10.0.0.4", + name: "Successful get all endpoints", podCmdOutput: "pod1\npod2\n", inspectCmdOutput: "mock_podSpec.json", expectedErr: nil, - expectedPodInfo: &cache.PodInfo{Name: "retina-pod", Namespace: "retina-namespace"}, + expectedCount: 2, + expectedRetinaEndpoint: common.NewRetinaEndpoint( + "retina-pod", + "retina-namespace", + common.NewIPAddress(net.ParseIP("10.0.0.4"), nil), + ), }, { - name: "No IP found in list of running pods", - ip: "10.0.0.0", - podCmdOutput: "pod1\npod2\n", - inspectCmdOutput: "mock_podSpec.json", - expectedErr: nil, - expectedPodInfo: nil, + name: "Get all running pods error", + getPodsErr: errGetPods, + expectedErr: errGetPods, + expectedCount: 0, + }, + { + name: "Inspect pod command error", + podCmdOutput: "pod1\npod2\n", + inspectPodErr: errInspectPod, + expectedErr: errInspectPod, + expectedCount: 0, }, { name: "Invalid pod spec JSON", - ip: "10.0.0.4", podCmdOutput: "pod1\npod2\n", inspectCmdOutput: invalidJSONPath, expectedErr: errJSONRead, - expectedPodInfo: nil, - }, - { - name: "Running pods error", - ip: "10.0.0.0", - getPodsErr: errGetPods, - expectedErr: errGetPods, - expectedPodInfo: nil, - }, - { - name: "Inspect pod error", - ip: "10.0.0.4", - podCmdOutput: "pod1\npod2\n", - inspectPodErr: errInspectPod, - expectedErr: errInspectPod, - expectedPodInfo: nil, + expectedCount: 0, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + originalCommand := crictlCommand + defer func() { crictlCommand = originalCommand }() + crictlCommand = func(_ string, args ...string) (string, error) { if strings.Contains(args[2], "pods") { if tt.getPodsErr != nil { @@ -94,17 +93,19 @@ func TestGetPodInfo(t *testing.T) { return "", errors.New("unknown command") } - podInfo, err := GetPodInfo(tt.ip) + endpoints, err := cs.GetAllEndpoints() if tt.expectedErr != nil { require.Error(t, err) require.ErrorContains(t, err, tt.expectedErr.Error()) - require.Nil(t, podInfo) + require.Nil(t, endpoints) } else { require.NoError(t, err) - require.Equal(t, tt.expectedPodInfo, podInfo) + require.Len(t, endpoints, tt.expectedCount) + if tt.expectedCount > 0 { + ep := endpoints[0] + require.Equal(t, tt.expectedRetinaEndpoint, ep) + } } - - crictlCommand = runCommand }) } } diff --git a/pkg/enricher/ctrinfo/mock_podSpec.json b/pkg/controllers/daemon/standalone/utils/mock_podSpec.json similarity index 100% rename from pkg/enricher/ctrinfo/mock_podSpec.json rename to pkg/controllers/daemon/standalone/utils/mock_podSpec.json diff --git a/pkg/controllers/daemon/standalone/utils/mock_source.go b/pkg/controllers/daemon/standalone/utils/mock_source.go new file mode 100644 index 0000000000..450303f887 --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/mock_source.go @@ -0,0 +1,56 @@ +// autogenerated +// +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. +// + +// Code generated by MockGen. DO NOT EDIT. +// Source: types.go + +// Package utils is a generated GoMock package. +package utils + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" + common "github.com/microsoft/retina/pkg/common" +) + +// MockSource is a mock of Source interface. +type MockSource struct { + ctrl *gomock.Controller + recorder *MockSourceMockRecorder +} + +// MockSourceMockRecorder is the mock recorder for MockSource. +type MockSourceMockRecorder struct { + mock *MockSource +} + +// NewMockSource creates a new mock instance. +func NewMockSource(ctrl *gomock.Controller) *MockSource { + mock := &MockSource{ctrl: ctrl} + mock.recorder = &MockSourceMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSource) EXPECT() *MockSourceMockRecorder { + return m.recorder +} + +// GetAllEndpoints mocks base method. +func (m *MockSource) GetAllEndpoints() ([]*common.RetinaEndpoint, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllEndpoints") + ret0, _ := ret[0].([]*common.RetinaEndpoint) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAllEndpoints indicates an expected call of GetAllEndpoints. +func (mr *MockSourceMockRecorder) GetAllEndpoints() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllEndpoints", reflect.TypeOf((*MockSource)(nil).GetAllEndpoints)) +} diff --git a/pkg/enricher/statefile/mock_statefile.json b/pkg/controllers/daemon/standalone/utils/mock_statefile.json similarity index 100% rename from pkg/enricher/statefile/mock_statefile.json rename to pkg/controllers/daemon/standalone/utils/mock_statefile.json diff --git a/pkg/enricher/statefile/helper.go b/pkg/controllers/daemon/standalone/utils/statefile.go similarity index 72% rename from pkg/enricher/statefile/helper.go rename to pkg/controllers/daemon/standalone/utils/statefile.go index 4b8ef7663c..a414402aa7 100644 --- a/pkg/enricher/statefile/helper.go +++ b/pkg/controllers/daemon/standalone/utils/statefile.go @@ -1,16 +1,19 @@ // Copyright (c) Microsoft Corporation. // Licensed under the MIT license. -package statefile +package utils import ( "encoding/json" "fmt" + "net" "os" - "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/microsoft/retina/pkg/common" ) +type StatefileSource struct{} + var StateFileLocation = "C:/Windows/System32/azure-vnet.json" type CniState struct { @@ -40,8 +43,8 @@ type IPInfo struct { IP string `json:"IP"` } -func GetPodInfo(ip, filePath string) (*cache.PodInfo, error) { - data, err := os.ReadFile(filePath) +func (ss *StatefileSource) GetAllEndpoints() ([]*common.RetinaEndpoint, error) { + data, err := os.ReadFile(StateFileLocation) if err != nil { return nil, fmt.Errorf("failed to read CNI state file: %w", err) } @@ -55,21 +58,27 @@ func GetPodInfo(ip, filePath string) (*cache.PodInfo, error) { return nil, fmt.Errorf("failed to decode CNI state file: %w", err) } + endpoints := []*common.RetinaEndpoint{} + // For every HNS endpoint, we check if the equivalent IP address exists in the CNI state file for _, iface := range cniState.Network.ExternalInterfaces { for _, networkInfo := range iface.Networks { for _, endpoint := range networkInfo.Endpoints { for _, ipInfo := range endpoint.IPAddresses { - if ipInfo.IP == ip { - return &cache.PodInfo{ - Name: endpoint.PodName, - Namespace: endpoint.PodNamespace, - }, nil + ip := ipInfo.IP + if ip == "" { + continue } + + endpoints = append(endpoints, common.NewRetinaEndpoint( + endpoint.PodName, + endpoint.PodNamespace, + common.NewIPAddress(net.ParseIP(ip), nil), + )) } } } } - return nil, nil + return endpoints, nil } diff --git a/pkg/controllers/daemon/standalone/utils/statefile_test.go b/pkg/controllers/daemon/standalone/utils/statefile_test.go new file mode 100644 index 0000000000..cbe581eb7b --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/statefile_test.go @@ -0,0 +1,107 @@ +// // Copyright (c) Microsoft Corporation. +// // Licensed under the MIT license. + +package utils + +import ( + "net" + "os" + "testing" + + "github.com/microsoft/retina/pkg/common" + "github.com/stretchr/testify/require" +) + +func TestStatefileGetAllEndpoints(t *testing.T) { + emptyJSONPath := "empty_azure_vnet.json" + emptyJSONContent := `` + err := os.WriteFile(emptyJSONPath, []byte(emptyJSONContent), 0o600) + require.NoError(t, err, "failed to create empty JSON file") + + invalidJSONPath := "mock_invalid_azure_vnet.json" + invalidJSONContent := `{ + "Network": { + "ExternalInterfaces": { + "eth0": { + "Networks": { + "192.0.0.5": { + "IpAddresses": [ + { + "IP": "192.0.0.5" + } + ], + "PodName": "retina2-pod", + "PodNamespace": "retina2-namespace" + } + } + } + } + } + ` + err = os.WriteFile(invalidJSONPath, []byte(invalidJSONContent), 0o600) + require.NoError(t, err, "failed to create invalid JSON file") + + defer os.Remove(emptyJSONPath) + defer os.Remove(invalidJSONPath) + + ss := &StatefileSource{} + + tests := []struct { + name string + filePath string + emptyFile bool + expectedEndpoint *common.RetinaEndpoint + expectedErr bool + }{ + { + name: "Valid state file", + filePath: "mock_statefile.json", + emptyFile: false, + expectedEndpoint: common.NewRetinaEndpoint("retina-pod", "retina-namespace", common.NewIPAddress(net.ParseIP("192.0.0.5"), nil)), + expectedErr: false, + }, + { + name: "Empty state file", + filePath: emptyJSONPath, + emptyFile: true, + expectedEndpoint: nil, + expectedErr: false, + }, + { + name: "Missing state file", + filePath: "non_existent_file.json", + emptyFile: false, + expectedEndpoint: nil, + expectedErr: true, + }, + { + name: "Invalid state file JSON", + expectedEndpoint: nil, + emptyFile: false, + filePath: invalidJSONPath, + expectedErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + originalPath := StateFileLocation + StateFileLocation = tt.filePath + defer func() { StateFileLocation = originalPath }() + + endpoints, err := ss.GetAllEndpoints() + + if tt.expectedErr { + require.Error(t, err) + require.Nil(t, endpoints) + } else { + require.NoError(t, err) + if tt.emptyFile { + require.Empty(t, endpoints) + } else { + require.Equal(t, tt.expectedEndpoint, endpoints[0]) + } + } + }) + } +} diff --git a/pkg/controllers/daemon/standalone/utils/types.go b/pkg/controllers/daemon/standalone/utils/types.go new file mode 100644 index 0000000000..f70e3f37b7 --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/types.go @@ -0,0 +1,11 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package utils + +import "github.com/microsoft/retina/pkg/common" + +type Source interface { + // GetAllEndpoints retrieves all retina endpoints from its corresponding source + GetAllEndpoints() ([]*common.RetinaEndpoint, error) +} diff --git a/pkg/enricher/standard.go b/pkg/enricher/enricher.go similarity index 75% rename from pkg/enricher/standard.go rename to pkg/enricher/enricher.go index 98013cd2ca..fea6cdba42 100644 --- a/pkg/enricher/standard.go +++ b/pkg/enricher/enricher.go @@ -38,18 +38,22 @@ type Enricher struct { Reader *container.RingReader outputRing *container.Ring + + // enableStandalone indicates whether the standalone enricher is enabled + enableStandalone bool } -func New(ctx context.Context, cache cache.CacheInterface) *Enricher { +func New(ctx context.Context, cache cache.CacheInterface, enableStandalone bool) *Enricher { once.Do(func() { ir := container.NewRing(container.Capacity1023) e = &Enricher{ - ctx: ctx, - l: log.Logger().Named("enricher"), - cache: cache, - inputRing: ir, - Reader: container.NewRingReader(ir, ir.OldestWrite()), - outputRing: container.NewRing(container.Capacity1023), + ctx: ctx, + l: log.Logger().Named("enricher"), + cache: cache, + inputRing: ir, + Reader: container.NewRingReader(ir, ir.OldestWrite()), + outputRing: container.NewRing(container.Capacity1023), + enableStandalone: enableStandalone, } initialized = true }) @@ -98,8 +102,37 @@ func (e *Enricher) Run() { }() } -// enrich takes the flow and enriches it with the information from the cache func (e *Enricher) enrich(ev *v1.Event) { + if e.enableStandalone { + e.enrichStandalone(ev) + } else { + e.enrichStandard(ev) + } +} + +// enrichStandalone takes the flow and enriches it with information from the standalone cache +func (e *Enricher) enrichStandalone(ev *v1.Event) { + flow := ev.Event.(*flow.Flow) + + if flow.IP.Source == "" { + e.l.Debug("source IP is empty") + return + } + + srcObj := e.cache.GetPodByIP(flow.IP.Source) + if srcObj != nil { + flow.Source = e.getEndpoint(srcObj) + e.l.Debug("enriched flow", zap.Any("flow", flow)) + } else { + flow.Source = nil + } + + ev.Event = flow + e.export(ev) +} + +// enrichStandard takes the flow and enriches it with the information from the cache +func (e *Enricher) enrichStandard(ev *v1.Event) { flow := ev.Event.(*flow.Flow) // IPversion is a enum in the flow proto diff --git a/pkg/enricher/standard_test.go b/pkg/enricher/enricher_test.go similarity index 59% rename from pkg/enricher/standard_test.go rename to pkg/enricher/enricher_test.go index cd05556d10..9413fff630 100644 --- a/pkg/enricher/standard_test.go +++ b/pkg/enricher/enricher_test.go @@ -14,6 +14,7 @@ import ( v1 "github.com/cilium/cilium/pkg/hubble/api/v1" "github.com/microsoft/retina/pkg/common" "github.com/microsoft/retina/pkg/controllers/cache" + "github.com/microsoft/retina/pkg/controllers/cache/standalone" "github.com/microsoft/retina/pkg/log" "github.com/microsoft/retina/pkg/pubsub" "github.com/stretchr/testify/assert" @@ -74,7 +75,7 @@ func TestEnricherSecondaryIPs(t *testing.T) { require.NoError(t, err) // get the enricher - e := New(ctx, c) + e := New(ctx, c, false) var wg sync.WaitGroup wg.Add(1) @@ -157,3 +158,133 @@ func addEvent(e *Enricher, sourceIP, destIP string) { time.Sleep(100 * time.Millisecond) e.Write(ev) } + +func TestEnricherStandalone_WithEndpointPresent(t *testing.T) { + opts := log.GetDefaultLogOpts() + opts.Level = "debug" + if _, err := log.SetupZapLogger(opts); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + + eventCount := 20 + expectedOutputCount := eventCount - 2 // last written event is not readable due to ring buffers + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + cache := standalone.NewCache() + sourceIP := "1.1.1.1" + + // Add endpoint to cache + endpoint := common.NewRetinaEndpoint("pod1", "ns1", &common.IPAddresses{IPv4: net.ParseIP(sourceIP)}) + require.NoError(t, cache.UpdateRetinaEndpoint(endpoint)) + + enricher := New(ctx, cache, true) + var wg sync.WaitGroup + + wg.Add(1) + go func() { + defer wg.Done() + for i := 0; i < eventCount; i++ { + ev := &v1.Event{ + Event: &flow.Flow{ + IP: &flow.IP{ + Source: sourceIP, + }, + }, + } + enricher.Write(ev) + time.Sleep(25 * time.Millisecond) + } + }() + + enricher.Run() + + wg.Add(1) + go func() { + defer wg.Done() + count := 0 + reader := enricher.ExportReader() + for { + ev := reader.NextFollow(ctx) + if ev == nil { + break + } + flow := ev.Event.(*flow.Flow) + sourceFlow := flow.GetSource() + + require.NotNil(t, sourceFlow, "Expected flow") + require.Equal(t, "pod1", sourceFlow.GetPodName()) + require.Equal(t, "ns1", sourceFlow.GetNamespace()) + + count++ + } + assert.Equal(t, expectedOutputCount, count, "Received event count mismatch") + }() + + time.Sleep(3 * time.Second) + cancel() + wg.Wait() +} + +func TestEnricherStandalone_WithEndpointAbsent(t *testing.T) { + opts := log.GetDefaultLogOpts() + opts.Level = "debug" + if _, err := log.SetupZapLogger(opts); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + + eventCount := 20 + expectedOutputCount := eventCount - 2 + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + cache := standalone.NewCache() + sourceIP := "9.9.9.9" // No endpoint added to cache + + enricher := New(ctx, cache, true) + var wg sync.WaitGroup + + wg.Add(1) + go func() { + defer wg.Done() + for i := 0; i < eventCount; i++ { + ev := &v1.Event{ + Event: &flow.Flow{ + IP: &flow.IP{ + Source: sourceIP, + }, + }, + } + enricher.Write(ev) + time.Sleep(25 * time.Millisecond) + } + }() + + enricher.Run() + + wg.Add(1) + go func() { + defer wg.Done() + count := 0 + reader := enricher.ExportReader() + for { + ev := reader.NextFollow(ctx) + if ev == nil { + break + } + flow := ev.Event.(*flow.Flow) + sourceFlow := flow.GetSource() + + require.Nil(t, sourceFlow) + + count++ + } + assert.Equal(t, expectedOutputCount, count, "Received event count mismatch") + }() + + time.Sleep(3 * time.Second) + cancel() + wg.Wait() +} diff --git a/pkg/enricher/standalone.go b/pkg/enricher/standalone.go deleted file mode 100644 index 2900f85d57..0000000000 --- a/pkg/enricher/standalone.go +++ /dev/null @@ -1,151 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. - -package enricher - -import ( - "context" - "errors" - "sync" - "time" - - "github.com/microsoft/retina/pkg/config" - "github.com/microsoft/retina/pkg/controllers/cache" - ctr "github.com/microsoft/retina/pkg/enricher/ctrinfo" - sf "github.com/microsoft/retina/pkg/enricher/statefile" - "github.com/microsoft/retina/pkg/log" - "go.uber.org/zap" -) - -var ( - se *StandaloneEnricher - localOnce sync.Once -) - -var ( - MaxStandaloneCacheEventSize = 250 - ErrEventChannelFull = errors.New("event channel is full, event dropped") -) - -type Action string - -const ( - AddEvent Action = "add" - DeleteEvent Action = "delete" -) - -type StandaloneEvent struct { - IP string - Action Action -} - -type StandaloneEnricher struct { - cfg *config.Config - ctx context.Context - l *log.ZapLogger - cache *cache.StandaloneCache - eventChannel chan StandaloneEvent -} - -func NewEnricher(ctx context.Context, standaloneCache *cache.StandaloneCache, cfg *config.Config) *StandaloneEnricher { - return &StandaloneEnricher{ - cfg: cfg, - ctx: ctx, - l: log.Logger().Named("standalone-enricher"), - cache: standaloneCache, - eventChannel: make(chan StandaloneEvent, MaxStandaloneCacheEventSize), - } -} - -func NewStandaloneEnricher(ctx context.Context, standaloneCache *cache.StandaloneCache, cfg *config.Config) *StandaloneEnricher { - localOnce.Do(func() { - se = NewEnricher(ctx, standaloneCache, cfg) - }) - return se -} - -func StandaloneInstance() *StandaloneEnricher { - return se -} - -func (e *StandaloneEnricher) Run() { - e.l.Info("Running standalone enricher") - if e.cfg.EnableCrictl { - e.l.Info("Using crictl enrichment") - } else { - e.l.Info("Using statefile enrichment") - } - - go func() { - for { - select { - case <-e.ctx.Done(): - e.l.Info("Standalone enricher shutting down...") - return - case event, ok := <-e.eventChannel: - if !ok { - e.l.Info("Event channel closed, stopping event processing") - return - } - switch event.Action { - case AddEvent: - e.l.Debug("Processing add event", zap.String("ip", event.IP)) - e.enrich(event.IP) - case DeleteEvent: - e.l.Debug("Processing delete event", zap.String("ip", event.IP)) - e.cache.Update(event.IP, nil) - default: - e.l.Warn("Unknown event action", zap.String("action", string(event.Action))) - } - } - } - }() -} - -func (e *StandaloneEnricher) enrich(ip string) { - var podInfo *cache.PodInfo - var err error - - if e.cfg.EnableCrictl { - podInfo, err = ctr.GetPodInfo(ip) - } else { - podInfo, err = sf.GetPodInfo(ip, sf.StateFileLocation) - } - - if err != nil { - e.l.Error("Failed to get pod info", zap.String("ip", ip), zap.Error(err)) - return - } - e.cache.Update(ip, podInfo) -} - -func (e *StandaloneEnricher) GetPodInfo(ip string) *cache.PodInfo { - return e.cache.GetPod(ip) -} - -func (e *StandaloneEnricher) PublishEvent(ip string, action Action) error { - select { - case e.eventChannel <- StandaloneEvent{IP: ip, Action: action}: - return nil - default: - e.l.Warn("Event channel full, dropping event", zap.String("ip", ip)) - return ErrEventChannelFull - } -} - -func (e *StandaloneEnricher) RemoveStaleEntries() { - e.cache.ForEach(func(ip string, podInfo *cache.PodInfo) { - if time.Since(podInfo.LastUpdate) > e.cache.TTL() { - e.l.Info("Removing stale entry from cache", zap.String("ip", ip)) - err := e.PublishEvent(ip, DeleteEvent) - if err != nil { - e.l.Error("Failed to publish delete event", zap.String("ip", ip), zap.Error(err)) - } - } - }) -} - -func (e *StandaloneEnricher) Stop() { - e.l.Info("Stopping standalone enricher...") - close(e.eventChannel) -} diff --git a/pkg/enricher/standalone_test.go b/pkg/enricher/standalone_test.go deleted file mode 100644 index 942146e61d..0000000000 --- a/pkg/enricher/standalone_test.go +++ /dev/null @@ -1,156 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. - -package enricher - -import ( - "context" - "testing" - "time" - - "github.com/microsoft/retina/pkg/config" - "github.com/microsoft/retina/pkg/controllers/cache" - sf "github.com/microsoft/retina/pkg/enricher/statefile" - "github.com/microsoft/retina/pkg/log" - "github.com/stretchr/testify/require" -) - -const testIP = "10.0.0.0" - -func TestPublishEvent(t *testing.T) { - if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { - t.Errorf("Error setting up logger: %s", err) - } - MaxStandaloneCacheEventSize = 1 - - tests := []struct { - name string - fillChannel bool - event StandaloneEvent - expectedErr error - }{ - { - name: "Event published successfully", - fillChannel: false, - event: StandaloneEvent{IP: testIP, Action: AddEvent}, - expectedErr: nil, - }, - { - name: "Event channel is full", - fillChannel: true, - event: StandaloneEvent{IP: testIP, Action: AddEvent}, - expectedErr: ErrEventChannelFull, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - if tt.fillChannel { - MaxStandaloneCacheEventSize = 0 - } - - testCache := cache.NewStandaloneCache(10 * time.Second) - e := NewEnricher(context.Background(), testCache, &config.Config{}) - - err := e.PublishEvent(tt.event.IP, tt.event.Action) - if tt.expectedErr != nil { - require.Error(t, err) - require.Equal(t, tt.expectedErr, err) - } else { - require.NoError(t, err) - } - }) - } -} - -func TestRemoveStaleEntries(t *testing.T) { - if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { - t.Errorf("Error setting up logger: %s", err) - } - - sf.StateFileLocation = "statefile/mock_statefile.json" - testCache := cache.NewStandaloneCache(1 * time.Millisecond) - e := NewEnricher(context.Background(), testCache, &config.Config{}) - e.Run() - defer e.Stop() - - podInfo := cache.PodInfo{Name: "retina-pod", Namespace: "retina-namespace", LastUpdate: time.Now()} - - testCache.Update(testIP, &podInfo) - time.Sleep(50 * time.Millisecond) - e.RemoveStaleEntries() - - require.Eventually(t, func() bool { - return testCache.GetPod(testIP) == nil - }, 100*time.Millisecond, 10*time.Millisecond, "Expected pod info should be nil after TTL expired") -} - -func TestRun(t *testing.T) { - if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { - t.Errorf("Error setting up logger: %s", err) - } - existingIP := "192.0.0.5" - nonExistingIP := testIP - - name := "retina-pod" - namespace := "retina-namespace" - sf.StateFileLocation = "statefile/mock_statefile.json" - MaxStandaloneCacheEventSize = 250 - - tests := []struct { - name string - event StandaloneEvent - setupCache func(c *cache.StandaloneCache) - expectedPodInfo *cache.PodInfo - }{ - { - name: "Successful cache update", - event: StandaloneEvent{IP: existingIP, Action: AddEvent}, - setupCache: func(_ *cache.StandaloneCache) {}, - expectedPodInfo: &cache.PodInfo{Name: name, Namespace: namespace}, - }, - { - name: "Successful cache deletion", - event: StandaloneEvent{IP: existingIP, Action: DeleteEvent}, - setupCache: func(c *cache.StandaloneCache) { - podInfo := cache.PodInfo{Name: name, Namespace: namespace} - c.Update(existingIP, &podInfo) - }, - expectedPodInfo: nil, - }, - { - name: "No update when pod info is empty", - event: StandaloneEvent{IP: nonExistingIP, Action: AddEvent}, - setupCache: func(_ *cache.StandaloneCache) {}, - expectedPodInfo: nil, - }, - { - name: "No update for unknown event", - event: StandaloneEvent{IP: existingIP, Action: Action("unknown")}, - setupCache: func(_ *cache.StandaloneCache) {}, - expectedPodInfo: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - testCache := cache.NewStandaloneCache(1 * time.Second) - e := NewEnricher(context.Background(), testCache, &config.Config{EnableCrictl: false}) - tt.setupCache(testCache) - - e.Run() - defer e.Stop() - - err := e.PublishEvent(tt.event.IP, tt.event.Action) - require.NoError(t, err) - - require.Eventually(t, func() bool { - podInfo := testCache.GetPod(tt.event.IP) - if tt.expectedPodInfo == nil { - return podInfo == nil - } - return podInfo != nil && podInfo.Name == tt.expectedPodInfo.Name && podInfo.Namespace == tt.expectedPodInfo.Namespace - }, 100*time.Millisecond, 10*time.Millisecond, "Pod info should match the expected pod info") - }) - } -} diff --git a/pkg/enricher/statefile/helper_test.go b/pkg/enricher/statefile/helper_test.go deleted file mode 100644 index 970fd23b8b..0000000000 --- a/pkg/enricher/statefile/helper_test.go +++ /dev/null @@ -1,103 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT license. - -package statefile - -import ( - "os" - "testing" - - "github.com/microsoft/retina/pkg/controllers/cache" - "github.com/stretchr/testify/require" -) - -func TestGetPodInfo(t *testing.T) { - emptyJSONPath := "empty_azure_vnet.json" - emptyJSONContent := `` - err := os.WriteFile(emptyJSONPath, []byte(emptyJSONContent), 0o600) - require.NoError(t, err, "failed to create empty JSON file") - - invalidJSONPath := "mock_invalid_azure_vnet.json" - invalidJSONContent := `{ - "Network": { - "ExternalInterfaces": { - "eth0": { - "Networks": { - "192.0.0.5": { - "IpAddresses": [ - { - "IP": "192.0.0.5" - } - ], - "PodName": "retina2-pod", - "PodNamespace": "retina2-namespace" - } - } - } - } - } - ` - err = os.WriteFile(invalidJSONPath, []byte(invalidJSONContent), 0o600) - require.NoError(t, err, "failed to create invalid JSON file") - - defer os.Remove(emptyJSONPath) - defer os.Remove(invalidJSONPath) - - tests := []struct { - name string - ip string - filePath string - expectedPodInfo *cache.PodInfo - expectedErr bool - }{ - { - name: "Valid IP match", - ip: "192.0.0.5", - filePath: "mock_statefile.json", - expectedPodInfo: &cache.PodInfo{Name: "retina-pod", Namespace: "retina-namespace"}, - expectedErr: false, - }, - { - name: "No IP match", - ip: "10.0.0.0", - filePath: "mock_statefile.json", - expectedPodInfo: nil, - expectedErr: false, - }, - { - name: "CNI state file not found", - ip: "10.0.0.0", - filePath: "non_existent_file.json", - expectedPodInfo: nil, - expectedErr: true, - }, - { - name: "Empty CNI state file", - ip: "10.0.0.0", - filePath: emptyJSONPath, - expectedPodInfo: nil, - expectedErr: false, - }, - { - name: "Invalid state file JSON", - ip: "10.0.0.0", - filePath: invalidJSONPath, - expectedPodInfo: nil, - expectedErr: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - podInfo, err := GetPodInfo(tt.ip, tt.filePath) - - if tt.expectedErr { - require.Error(t, err) - require.Nil(t, podInfo) - } else { - require.NoError(t, err) - require.Equal(t, tt.expectedPodInfo, podInfo) - } - }) - } -} diff --git a/pkg/managers/controllermanager/controllermanager.go b/pkg/managers/controllermanager/controllermanager.go index 0ee6b46479..84113f4f8b 100644 --- a/pkg/managers/controllermanager/controllermanager.go +++ b/pkg/managers/controllermanager/controllermanager.go @@ -83,7 +83,7 @@ func (m *Controller) Init(ctx context.Context) error { m.cache = cache.New(m.pubsub) // create enricher instance - m.enricher = enricher.New(ctx, m.cache) + m.enricher = enricher.New(ctx, m.cache, m.conf.EnableStandalone) } return nil diff --git a/pkg/module/metrics/basemetricsobject.go b/pkg/module/metrics/basemetricsobject.go index 19f0b9e675..35eda64e90 100644 --- a/pkg/module/metrics/basemetricsobject.go +++ b/pkg/module/metrics/basemetricsobject.go @@ -49,5 +49,5 @@ func (b *baseMetricObject) populateCtxOptions(ctxOptions *api.MetricsContextOpti } func (b *baseMetricObject) isLocalContext() bool { - return b.contextMode == localContext + return b.contextMode == LocalContext } diff --git a/pkg/module/metrics/dns.go b/pkg/module/metrics/dns.go index 003d14cb3d..b4528e6720 100644 --- a/pkg/module/metrics/dns.go +++ b/pkg/module/metrics/dns.go @@ -238,5 +238,6 @@ func (d *DNSMetrics) processLocalCtxFlow(flow *v1.Flow) { } func (d *DNSMetrics) Clean() { + d.l.Info("Cleaning metric", zap.String("name", d.metricName)) exporter.UnregisterMetric(exporter.AdvancedRegistry, metricsinit.ToPrometheusType(d.dnsMetrics)) } diff --git a/pkg/module/metrics/drops.go b/pkg/module/metrics/drops.go index cf5db7d7a1..b5b4f12fa7 100644 --- a/pkg/module/metrics/drops.go +++ b/pkg/module/metrics/drops.go @@ -25,11 +25,12 @@ const ( type DropCountMetrics struct { baseMetricObject - dropMetric metrics.GaugeVec - metricName string + dropMetric metrics.GaugeVec + metricName string + enableStandalone bool } -func NewDropCountMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isLocalContext enrichmentContext) *DropCountMetrics { +func NewDropCountMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isLocalContext enrichmentContext, enableStandalone bool) *DropCountMetrics { if ctxOptions == nil || !strings.Contains(strings.ToLower(ctxOptions.MetricName), "drop") { return nil } @@ -38,6 +39,7 @@ func NewDropCountMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogge fl.Info("Creating drop count metrics", zap.Any("options", ctxOptions)) return &DropCountMetrics{ baseMetricObject: newBaseMetricsObject(ctxOptions, fl, isLocalContext), + enableStandalone: enableStandalone, } } @@ -83,6 +85,7 @@ func (d *DropCountMetrics) getLabels() []string { } func (d *DropCountMetrics) Clean() { + d.l.Info("Cleaning metric", zap.String("name", d.metricName)) exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(d.dropMetric)) } @@ -95,6 +98,11 @@ func (d *DropCountMetrics) ProcessFlow(flow *v1.Flow) { return } + if d.enableStandalone { + d.processStandaloneFlow(flow) + return + } + if flow.Verdict != v1.Verdict_DROPPED { return } @@ -169,3 +177,34 @@ func (d *DropCountMetrics) update(fl *v1.Flow, labels []string) { d.dropMetric.WithLabelValues(labels...).Add(float64(utils.PacketSize(fl))) } } + +func (d *DropCountMetrics) processStandaloneFlow(fl *v1.Flow) { + // Ingress values + ingressLbls := []string{ + ingress, + fl.GetIP().Source, + fl.Source.Namespace, + fl.Source.PodName, + "", + "", + } + // Egress values + egressLbls := []string{ + egress, + fl.GetIP().Source, + fl.Source.Namespace, + fl.Source.PodName, + "", + "", + } + + d.dropMetric.WithLabelValues(append([]string{utils.Endpoint}, ingressLbls...)...).Set(float64(GetHNSMetadata(fl).EndpointStats.DroppedPacketsIncoming)) + d.dropMetric.WithLabelValues(append([]string{utils.Endpoint}, egressLbls...)...).Set(float64(GetHNSMetadata(fl).EndpointStats.DroppedPacketsOutgoing)) + + if GetHNSMetadata(fl).VfpPortStatsData == nil { + return + } + + d.dropMetric.WithLabelValues(append([]string{utils.AclRule}, ingressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.In.DropCounters.AclDropPacketCount)) + d.dropMetric.WithLabelValues(append([]string{utils.AclRule}, egressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.Out.DropCounters.AclDropPacketCount)) +} diff --git a/pkg/module/metrics/drops_test.go b/pkg/module/metrics/drops_test.go index bc2e9f707f..2d86afff62 100644 --- a/pkg/module/metrics/drops_test.go +++ b/pkg/module/metrics/drops_test.go @@ -5,12 +5,16 @@ package metrics import ( + "strings" "testing" "github.com/cilium/cilium/api/v1/flow" "github.com/microsoft/retina/crd/api/v1alpha1" + api "github.com/microsoft/retina/crd/api/v1alpha1" + "github.com/microsoft/retina/pkg/exporter" "github.com/microsoft/retina/pkg/log" metricsinit "github.com/microsoft/retina/pkg/metrics" + "github.com/microsoft/retina/pkg/utils" "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/assert" "go.uber.org/mock/gomock" @@ -209,7 +213,7 @@ func TestNewDrop(t *testing.T) { }, metricCall: 1, nilObj: false, - localContext: localContext, + localContext: LocalContext, }, { name: "drop source opts with destination flow in localcontext", @@ -235,7 +239,7 @@ func TestNewDrop(t *testing.T) { }, metricCall: 1, nilObj: false, - localContext: localContext, + localContext: LocalContext, }, { name: "drop source opts with source and destination flow in localcontext", @@ -262,7 +266,7 @@ func TestNewDrop(t *testing.T) { }, metricCall: 2, nilObj: false, - localContext: localContext, + localContext: LocalContext, }, } @@ -270,7 +274,7 @@ func TestNewDrop(t *testing.T) { for _, metricName := range []string{"drop_count", "drop_bytes"} { log.Logger().Info("Running test name", zap.String("name", tc.name), zap.String("metricName", metricName)) ctrl := gomock.NewController(t) - f := NewDropCountMetrics(tc.opts, log.Logger(), tc.localContext) + f := NewDropCountMetrics(tc.opts, log.Logger(), tc.localContext, false) if tc.nilObj { assert.Nil(t, f, "drop metrics should be nil Test Name: %s", tc.name) continue @@ -297,3 +301,89 @@ func TestNewDrop(t *testing.T) { } } } + +func TestStandaloneDropMetrics(t *testing.T) { + logger, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + ctxOptions := &api.MetricsContextOptions{ + MetricName: utils.DroppedPacketsGaugeName, + SourceLabels: append(DefaultCtxOptions(), utils.Reason, utils.Direction), + } + + drop := NewDropCountMetrics(ctxOptions, logger, LocalContext, true) + drop.Init(ctxOptions.MetricName) + + originalGetHNS := GetHNSMetadata + GetHNSMetadata = func(flow *flow.Flow) *utils.HNSStatsMetadata { + return &utils.HNSStatsMetadata{ + EndpointStats: &utils.EndpointStats{ + DroppedPacketsIncoming: 0, + DroppedPacketsOutgoing: 99, + }, + VfpPortStatsData: &utils.VfpPortStatsData{ + In: &utils.VfpDirectedPortCounters{ + DropCounters: &utils.VfpPacketDropStats{ + AclDropPacketCount: 100, + }, + }, + Out: &utils.VfpDirectedPortCounters{ + DropCounters: &utils.VfpPacketDropStats{ + AclDropPacketCount: 199, + }, + }, + }, + } + } + defer func() { GetHNSMetadata = originalGetHNS }() + + testFlow := &flow.Flow{ + IP: &flow.IP{Source: "1.1.1.1"}, + Source: &flow.Endpoint{ + Namespace: "default", + PodName: "test-pod", + }, + } + + drop.ProcessFlow(testFlow) + + mfs, err := exporter.AdvancedRegistry.Gather() + assert.NoError(t, err) + var validMetricCount int + + for _, mf := range mfs { + if !strings.Contains(mf.GetName(), utils.DroppedPacketsGaugeName) { + continue + } + t.Logf("Metric Family: %s", mf.GetName()) + + for _, m := range mf.GetMetric() { + labelMap := map[string]string{} + for _, label := range m.GetLabel() { + labelMap[label.GetName()] = label.GetValue() + } + assert.Equal(t, "1.1.1.1", labelMap["ip"]) + assert.Equal(t, "default", labelMap["namespace"]) + assert.Equal(t, "test-pod", labelMap["podname"]) + assert.Equal(t, "", labelMap["workload_kind"]) + assert.Equal(t, "", labelMap["workload_name"]) + + if labelMap["direction"] == "ingress" && labelMap["reason"] == utils.Endpoint { + assert.Equal(t, float64(0), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "ingress" && labelMap["reason"] == utils.AclRule { + assert.Equal(t, float64(100), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "egress" && labelMap["reason"] == utils.Endpoint { + assert.Equal(t, float64(99), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "egress" && labelMap["reason"] == utils.AclRule { + assert.Equal(t, float64(199), m.GetGauge().GetValue()) + validMetricCount++ + } + } + } + + assert.Equal(t, 4, validMetricCount, "Expected 4 metric samples with correct labels and values") + +} diff --git a/pkg/module/metrics/forward.go b/pkg/module/metrics/forward.go index 9ed694b2f3..104d2ab3bc 100644 --- a/pkg/module/metrics/forward.go +++ b/pkg/module/metrics/forward.go @@ -30,11 +30,12 @@ const ( type ForwardMetrics struct { baseMetricObject forwardMetric metricsinit.GaugeVec - // bytesMetric metricsinit.IGaugeVec - metricName string + // bytesMetric metricsinit.GaugeVec + metricName string + enableStandalone bool } -func NewForwardCountMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isLocalContext enrichmentContext) *ForwardMetrics { +func NewForwardCountMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isLocalContext enrichmentContext, enableStandalone bool) *ForwardMetrics { if ctxOptions == nil || !strings.Contains(strings.ToLower(ctxOptions.MetricName), "forward") { return nil } @@ -43,6 +44,7 @@ func NewForwardCountMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLo l.Info("Creating forward count metrics", zap.Any("options", ctxOptions)) return &ForwardMetrics{ baseMetricObject: newBaseMetricsObject(ctxOptions, fl, isLocalContext), + enableStandalone: enableStandalone, } } @@ -54,12 +56,14 @@ func (f *ForwardMetrics) Init(metricName string) { TotalCountName, TotalCountDesc, f.getLabels()...) + f.l.Info("Initialized forward packets metric") case utils.ForwardBytesGaugeName: f.forwardMetric = exporter.CreatePrometheusGaugeVecForMetric( exporter.AdvancedRegistry, TotalBytesName, TotalBytesDesc, f.getLabels()...) + f.l.Info("Initialized forward bytes metric") default: f.l.Error("unknown metric name", zap.String("name", metricName)) } @@ -93,6 +97,7 @@ func (f *ForwardMetrics) getLabels() []string { } func (f *ForwardMetrics) Clean() { + f.l.Info("Cleaning metric", zap.String("name", f.metricName)) exporter.UnregisterMetric(exporter.AdvancedRegistry, metricsinit.ToPrometheusType(f.forwardMetric)) } @@ -105,6 +110,11 @@ func (f *ForwardMetrics) ProcessFlow(flow *v1.Flow) { return } + if f.enableStandalone { + f.processStandaloneFlow(flow) + return + } + if flow.Verdict != v1.Verdict_FORWARDED { return } @@ -175,3 +185,33 @@ func (f *ForwardMetrics) update(fl *v1.Flow, labels []string) { f.forwardMetric.WithLabelValues(labels...).Add(float64(utils.PacketSize(fl) + utils.PreviouslyObservedBytes(fl))) } } + +func (f *ForwardMetrics) processStandaloneFlow(fl *v1.Flow) { + // Ingress values + ingressLbls := []string{ + ingress, + fl.GetIP().Source, + fl.Source.Namespace, + fl.Source.PodName, + "", + "", + } + // Egress values + egressLbls := []string{ + egress, + fl.GetIP().Source, + fl.Source.Namespace, + fl.Source.PodName, + "", + "", + } + + switch f.metricName { + case utils.ForwardPacketsGaugeName: + f.forwardMetric.WithLabelValues(ingressLbls...).Set(float64(GetHNSMetadata(fl).EndpointStats.PacketsReceived)) + f.forwardMetric.WithLabelValues(egressLbls...).Set(float64(GetHNSMetadata(fl).EndpointStats.PacketsSent)) + case utils.ForwardBytesGaugeName: + f.forwardMetric.WithLabelValues(ingressLbls...).Set(float64(GetHNSMetadata(fl).EndpointStats.BytesReceived)) + f.forwardMetric.WithLabelValues(egressLbls...).Set(float64(GetHNSMetadata(fl).EndpointStats.BytesSent)) + } +} diff --git a/pkg/module/metrics/forward_test.go b/pkg/module/metrics/forward_test.go index 1af7558483..9fad8361d4 100644 --- a/pkg/module/metrics/forward_test.go +++ b/pkg/module/metrics/forward_test.go @@ -5,12 +5,16 @@ package metrics import ( + "strings" "testing" "github.com/cilium/cilium/api/v1/flow" "github.com/microsoft/retina/crd/api/v1alpha1" + api "github.com/microsoft/retina/crd/api/v1alpha1" + "github.com/microsoft/retina/pkg/exporter" "github.com/microsoft/retina/pkg/log" metricsinit "github.com/microsoft/retina/pkg/metrics" + "github.com/microsoft/retina/pkg/utils" "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/assert" "go.uber.org/mock/gomock" @@ -224,7 +228,7 @@ func TestNewForward(t *testing.T) { "port", }, metricCall: 1, - localContext: localContext, + localContext: LocalContext, }, { name: "dest opts 1 with flow in local context", @@ -248,7 +252,7 @@ func TestNewForward(t *testing.T) { "port", }, metricCall: 1, - localContext: localContext, + localContext: LocalContext, }, { name: "src and dest opts 1 with flow in local context", @@ -273,7 +277,7 @@ func TestNewForward(t *testing.T) { "port", }, metricCall: 2, - localContext: localContext, + localContext: LocalContext, }, { name: "src and dest opts 1 with flow in local context and is_reply", @@ -300,7 +304,7 @@ func TestNewForward(t *testing.T) { "is_reply", }, metricCall: 2, - localContext: localContext, + localContext: LocalContext, }, } @@ -309,7 +313,7 @@ func TestNewForward(t *testing.T) { l.Info("Running test", zap.String("name", tc.name), zap.String("metricName", metricName)) ctrl := gomock.NewController(t) - f := NewForwardCountMetrics(tc.opts, log.Logger(), tc.localContext) + f := NewForwardCountMetrics(tc.opts, log.Logger(), tc.localContext, false) if tc.nilObj { assert.Nil(t, f, "forward metrics should be nil Test Name: %s", tc.name) continue @@ -335,3 +339,72 @@ func TestNewForward(t *testing.T) { } } } + +func TestStandaloneForwardMetrics(t *testing.T) { + logger, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + ctxOptions := &api.MetricsContextOptions{ + MetricName: "forward", + SourceLabels: append([]string{utils.Direction}, DefaultCtxOptions()...), + } + + forward := NewForwardCountMetrics(ctxOptions, logger, LocalContext, true) + forward.Init(ctxOptions.MetricName) + + originalGetHNS := GetHNSMetadata + GetHNSMetadata = func(flow *flow.Flow) *utils.HNSStatsMetadata { + return &utils.HNSStatsMetadata{ + EndpointStats: &utils.EndpointStats{ + PacketsReceived: 42, + PacketsSent: 99, + BytesReceived: 42, + BytesSent: 99, + }, + } + } + defer func() { GetHNSMetadata = originalGetHNS }() + + testFlow := &flow.Flow{ + IP: &flow.IP{Source: "1.1.1.1"}, + Source: &flow.Endpoint{ + Namespace: "default", + PodName: "test-pod", + }, + } + + forward.ProcessFlow(testFlow) + + mfs, err := exporter.AdvancedRegistry.Gather() + assert.NoError(t, err) + var validMetricCount int + + for _, mf := range mfs { + if !strings.Contains(mf.GetName(), TotalCountName) && !strings.Contains(mf.GetName(), TotalBytesName) { + continue + } + t.Logf("Metric Family: %s", mf.GetName()) + + for _, m := range mf.GetMetric() { + labelMap := map[string]string{} + for _, label := range m.GetLabel() { + labelMap[label.GetName()] = label.GetValue() + } + assert.Equal(t, "1.1.1.1", labelMap["ip"]) + assert.Equal(t, "default", labelMap["namespace"]) + assert.Equal(t, "test-pod", labelMap["podname"]) + assert.Equal(t, "", labelMap["workload_kind"]) + assert.Equal(t, "", labelMap["workload_name"]) + + if labelMap["direction"] == "ingress" { + assert.Equal(t, float64(42), m.GetGauge().GetValue()) + validMetricCount++ + } else { + assert.Equal(t, float64(99), m.GetGauge().GetValue()) + validMetricCount++ + } + } + } + + assert.Equal(t, 4, validMetricCount, "Expected 4 metric samples with correct labels and values") +} diff --git a/pkg/module/metrics/hns.go b/pkg/module/metrics/hns.go new file mode 100644 index 0000000000..e36752f97b --- /dev/null +++ b/pkg/module/metrics/hns.go @@ -0,0 +1,91 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. +package metrics + +import ( + v1 "github.com/cilium/cilium/api/v1/flow" + api "github.com/microsoft/retina/crd/api/v1alpha1" + "github.com/microsoft/retina/pkg/exporter" + "github.com/microsoft/retina/pkg/log" + "github.com/microsoft/retina/pkg/metrics" + metricsinit "github.com/microsoft/retina/pkg/metrics" + "github.com/microsoft/retina/pkg/utils" + "go.uber.org/zap" +) + +const ( + // Metric names + hnsStatsName = "adv_windows_hns_stats" + PacketsReceived = "win_packets_recv_count" + PacketsSent = "win_packets_sent_count" + + // Metric descriptions + hnsStatsDesc = "Include many different metrics from packets sent/received to closed connections" +) + +var GetHNSMetadata = utils.GetHNSMetadata + +type HNSMetrics struct { + baseMetricObject + hnsStatsMetrics metricsinit.GaugeVec + metricName string +} + +func NewHNSMetrics(ctxOptions *api.MetricsContextOptions, l *log.ZapLogger, isLocalContext enrichmentContext) *HNSMetrics { + l = l.Named("hns-metricsmodule") + l.Info("Creating HNS metrics") + return &HNSMetrics{ + baseMetricObject: newBaseMetricsObject(ctxOptions, l, isLocalContext), + } +} + +func (h *HNSMetrics) getLabels() []string { + labels := append(h.srcCtx.getLabels(), utils.Direction) + h.l.Info("src labels", zap.Any("labels", labels)) + return labels +} + +func (h *HNSMetrics) Init(metricName string) { + h.hnsStatsMetrics = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + hnsStatsName, + hnsStatsDesc, + h.getLabels()..., + ) + h.metricName = metricName +} + +func (h *HNSMetrics) ProcessFlow(flow *v1.Flow) { + if flow == nil { + return + } + + // Ingress values + ingressVal := GetHNSMetadata(flow).EndpointStats.PacketsReceived + ingressLbls := []string{ + flow.GetIP().Source, + flow.Source.Namespace, + flow.Source.PodName, + "", + "", + PacketsReceived, + } + h.hnsStatsMetrics.WithLabelValues(ingressLbls...).Set(float64(ingressVal)) + + // Egress values + egressVal := GetHNSMetadata(flow).EndpointStats.PacketsSent + egressLbls := []string{ + flow.GetIP().Source, + flow.Source.Namespace, + flow.Source.PodName, + "", + "", + PacketsSent, + } + h.hnsStatsMetrics.WithLabelValues(egressLbls...).Set(float64(egressVal)) +} + +func (h *HNSMetrics) Clean() { + h.l.Info("Cleaning metric", zap.String("name", h.metricName)) + exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(h.hnsStatsMetrics)) +} diff --git a/pkg/module/metrics/hns_test.go b/pkg/module/metrics/hns_test.go new file mode 100644 index 0000000000..cb8db05813 --- /dev/null +++ b/pkg/module/metrics/hns_test.go @@ -0,0 +1,79 @@ +package metrics + +import ( + "strings" + "testing" + + "github.com/alecthomas/assert/v2" + "github.com/cilium/cilium/api/v1/flow" + api "github.com/microsoft/retina/crd/api/v1alpha1" + "github.com/microsoft/retina/pkg/exporter" + "github.com/microsoft/retina/pkg/log" + "github.com/microsoft/retina/pkg/utils" +) + +func TestHNSMetrics(t *testing.T) { + logger, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + ctxOptions := &api.MetricsContextOptions{ + MetricName: "hns", + SourceLabels: append(DefaultCtxOptions(), utils.Direction), + } + + hns := NewHNSMetrics(ctxOptions, logger, LocalContext) + hns.Init(ctxOptions.MetricName) + + originalGetHNS := GetHNSMetadata + GetHNSMetadata = func(flow *flow.Flow) *utils.HNSStatsMetadata { + return &utils.HNSStatsMetadata{ + EndpointStats: &utils.EndpointStats{ + PacketsReceived: 42, + PacketsSent: 99, + }, + } + } + defer func() { GetHNSMetadata = originalGetHNS }() + + testFlow := &flow.Flow{ + IP: &flow.IP{Source: "1.1.1.1"}, + Source: &flow.Endpoint{ + Namespace: "default", + PodName: "test-pod", + }, + } + + hns.ProcessFlow(testFlow) + + mfs, err := exporter.AdvancedRegistry.Gather() + assert.NoError(t, err) + var validMetricCount int + + for _, mf := range mfs { + if !strings.Contains(mf.GetName(), hnsStatsName) { + continue + } + t.Logf("Metric Family: %s", mf.GetName()) + + for _, m := range mf.GetMetric() { + labelMap := map[string]string{} + for _, label := range m.GetLabel() { + labelMap[label.GetName()] = label.GetValue() + } + assert.Equal(t, "1.1.1.1", labelMap["ip"]) + assert.Equal(t, "default", labelMap["namespace"]) + assert.Equal(t, "test-pod", labelMap["podname"]) + assert.Equal(t, "", labelMap["workload_kind"]) + assert.Equal(t, "", labelMap["workload_name"]) + + if labelMap["direction"] == PacketsReceived { + assert.Equal(t, float64(42), m.GetGauge().GetValue()) + validMetricCount++ + } else { + assert.Equal(t, float64(99), m.GetGauge().GetValue()) + validMetricCount++ + } + } + } + assert.Equal(t, 2, validMetricCount, "Expected 2 metric samples with correct labels and values") +} diff --git a/pkg/module/metrics/metrics_module.go b/pkg/module/metrics/metrics_module.go index 0d38c06522..9178baa889 100644 --- a/pkg/module/metrics/metrics_module.go +++ b/pkg/module/metrics/metrics_module.go @@ -26,9 +26,9 @@ import ( ) const ( - forward string = "forward" - drop string = "drop" - tcp string = "tcp" + Forward string = "forward" + Drop string = "drop" + TCP string = "tcp" nodeApiserver string = "node_apiserver" dns string = "dns" pktmon string = "pktmon" @@ -217,23 +217,23 @@ func (m *Module) updateMetricsContexts(spec *api.MetricsSpec) { // when localcontext is enabled, we do not need the context options for both src and dst // metrics aggregation will be on a single pod basis and not the src/dst pod combination basis. // so we can getaway with just one context type. For this reason we will only use srccontext - ctxType = localContext + ctxType = LocalContext } for _, ctxOption := range spec.ContextOptions { switch { - case strings.Contains(ctxOption.MetricName, forward): - fm := NewForwardCountMetrics(&ctxOption, m.l, ctxType) + case strings.Contains(ctxOption.MetricName, Forward): + fm := NewForwardCountMetrics(&ctxOption, m.l, ctxType, m.daemonConfig.EnableStandalone) if fm != nil { m.registry[ctxOption.MetricName] = fm } - case strings.Contains(ctxOption.MetricName, drop): - dm := NewDropCountMetrics(&ctxOption, m.l, ctxType) + case strings.Contains(ctxOption.MetricName, Drop): + dm := NewDropCountMetrics(&ctxOption, m.l, ctxType, m.daemonConfig.EnableStandalone) if dm != nil { m.registry[ctxOption.MetricName] = dm } - case strings.Contains(ctxOption.MetricName, tcp): - tm := NewTCPMetrics(&ctxOption, m.l, ctxType) + case strings.Contains(ctxOption.MetricName, TCP): + tm := NewTCPMetrics(&ctxOption, m.l, ctxType, m.daemonConfig.EnableStandalone) if tm != nil { m.registry[ctxOption.MetricName] = tm } diff --git a/pkg/module/metrics/standalone/metrics_module.go b/pkg/module/metrics/standalone/metrics_module.go new file mode 100644 index 0000000000..479440c9e6 --- /dev/null +++ b/pkg/module/metrics/standalone/metrics_module.go @@ -0,0 +1,146 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. +package standalone + +import ( + "context" + "strings" + "sync" + + "github.com/cilium/cilium/api/v1/flow" + api "github.com/microsoft/retina/crd/api/v1alpha1" + mm "github.com/microsoft/retina/pkg/module/metrics" + + "github.com/microsoft/retina/pkg/enricher" + "github.com/microsoft/retina/pkg/exporter" + "github.com/microsoft/retina/pkg/log" + "github.com/microsoft/retina/pkg/module/metrics" + + "go.uber.org/zap" +) + +const ( + HNS string = "hns" +) + +var ( + m *Module + once sync.Once + requiredMetrics = mm.DefaultStandaloneMetrics() +) + +type Module struct { + *sync.RWMutex + // ctx is the parent context + ctx context.Context + + // l is the zaplogger + l *log.ZapLogger + + // enricher to read events from + enricher enricher.EnricherInterface + + // registry is the advanced metrics registry + registry map[string]metrics.AdvMetricsInterface +} + +func InitModule(ctx context.Context, enricher enricher.EnricherInterface) *Module { + once.Do(func() { + m = &Module{ + RWMutex: &sync.RWMutex{}, + l: log.Logger().Named("StandaloneMetricModule"), + enricher: enricher, + registry: make(map[string]metrics.AdvMetricsInterface), + } + m.updateMetricsContext() + }) + + return m +} + +func (m *Module) Reconcile(ctx context.Context) { + go func() { + m.Lock() + m.ctx = ctx + m.Unlock() + + m.l.Info("Reconciling metric module") + + evReader := m.enricher.ExportReader() + for { + ev := evReader.NextFollow(ctx) + if ev == nil { + break + } + switch f := ev.Event.(type) { + case *flow.Flow: + m.RLock() + for _, metricObj := range m.registry { + // Flow will be empty if IP doesnt exist + metricObj.ProcessFlow(f) + } + m.RUnlock() + default: + m.l.Warn("Unknown event type", zap.Any("event", ev)) + } + } + + if err := evReader.Close(); err != nil { + m.l.Error("Error closing event reader", zap.Error(err)) + } + }() +} + +// updateMetricsContext updates the metrics context by resetting the registry and re-initializing metrics +func (m *Module) updateMetricsContext() { + // clean old metrics and reset registry + m.Clear() + + spec := (&api.MetricsSpec{}).WithMetricsContextOptions(requiredMetrics, mm.DefaultCtxOptions(), mm.DefaultCtxOptions()) + ctxType := mm.LocalContext + + exporter.ResetAdvancedMetricsRegistry() + + for _, ctxOption := range spec.ContextOptions { + switch { + case strings.Contains(ctxOption.MetricName, metrics.Forward): + fm := metrics.NewForwardCountMetrics(&ctxOption, m.l, ctxType, true) + if fm != nil { + m.registry[ctxOption.MetricName] = fm + } + case strings.Contains(ctxOption.MetricName, HNS): + hns := metrics.NewHNSMetrics(&ctxOption, m.l, ctxType) + if hns != nil { + m.registry[ctxOption.MetricName] = hns + } + case strings.Contains(ctxOption.MetricName, metrics.Drop): + dm := metrics.NewDropCountMetrics(&ctxOption, m.l, ctxType, true) + if dm != nil { + m.registry[ctxOption.MetricName] = dm + } + case strings.Contains(ctxOption.MetricName, metrics.TCP): + tc := metrics.NewTCPConnectionMetrics(&ctxOption, m.l, ctxType) + if tc != nil { + m.registry[ctxOption.MetricName] = tc + } + tcp := metrics.NewTCPMetrics(&ctxOption, m.l, ctxType, true) + if tcp != nil { + m.registry[ctxOption.MetricName] = tcp + } + default: + m.l.Error("Invalid metric name", zap.String("metricName", ctxOption.MetricName)) + } + } + + for metricName, metricObj := range m.registry { + metricObj.Init(metricName) + } +} + +// Clear removes all metrics from the registry +func (m *Module) Clear() { + for key, metricObj := range m.registry { + metricObj.Clean() + delete(m.registry, key) + } +} diff --git a/pkg/module/metrics/standalone/metrics_module_test.go b/pkg/module/metrics/standalone/metrics_module_test.go new file mode 100644 index 0000000000..aa62094f33 --- /dev/null +++ b/pkg/module/metrics/standalone/metrics_module_test.go @@ -0,0 +1,170 @@ +package standalone + +import ( + "context" + "strings" + "testing" + "time" + + "github.com/cilium/cilium/api/v1/flow" + v1 "github.com/cilium/cilium/pkg/hubble/api/v1" + "github.com/cilium/cilium/pkg/hubble/container" + + "github.com/microsoft/retina/pkg/enricher" + "github.com/microsoft/retina/pkg/exporter" + "github.com/microsoft/retina/pkg/log" + "github.com/microsoft/retina/pkg/metrics" + mm "github.com/microsoft/retina/pkg/module/metrics" + "github.com/microsoft/retina/pkg/utils" + "github.com/stretchr/testify/assert" + + "github.com/stretchr/testify/require" + gomock "go.uber.org/mock/gomock" +) + +func TestInitModule(t *testing.T) { + _, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + tests := []struct { + name string + wantRegistryKeys []string + expectCleanup bool + }{ + { + name: "Successful initialization", + wantRegistryKeys: []string{ + utils.ForwardPacketsGaugeName, + utils.ForwardBytesGaugeName, + utils.TCPConnectionStatsName, + utils.TCPFlagGauge, + metrics.HNSStats, + utils.DroppedPacketsGaugeName, + }, + expectCleanup: false, + }, + { + name: "Successful cleanup after initialization", + wantRegistryKeys: []string{ + utils.ForwardPacketsGaugeName, + utils.ForwardBytesGaugeName, + utils.TCPConnectionStatsName, + utils.TCPFlagGauge, + metrics.HNSStats, + utils.DroppedPacketsGaugeName, + }, + expectCleanup: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + enr := enricher.NewMockEnricherInterface(ctrl) + m := InitModule(ctx, enr) + assert.NotNil(t, m) + + registryKeys := make([]string, 0, len(m.registry)) + for k := range m.registry { + registryKeys = append(registryKeys, k) + } + + for _, wantKey := range tt.wantRegistryKeys { + assert.Contains(t, registryKeys, wantKey, "expected registry to contain %q", wantKey) + } + + if tt.expectCleanup { + m.Clear() + assert.Equal(t, 0, len(m.registry)) + } + }) + } +} + +func TestReconcile(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + _, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + require.NoError(t, err) + + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + enr := enricher.NewMockEnricherInterface(ctrl) + testRing := container.NewRing(container.Capacity1) + testRingReader := container.NewRingReader(testRing, 0) + enr.EXPECT().ExportReader().AnyTimes().Return(testRingReader) + + originalGetHNS := mm.GetHNSMetadata + originalRequiredMetrics := requiredMetrics + mm.GetHNSMetadata = func(flow *flow.Flow) *utils.HNSStatsMetadata { + return &utils.HNSStatsMetadata{ + EndpointStats: &utils.EndpointStats{ + PacketsReceived: 42, + PacketsSent: 99, + }, + } + } + requiredMetrics = []string{metrics.HNSStats} + defer func() { + mm.GetHNSMetadata = originalGetHNS + requiredMetrics = originalRequiredMetrics + }() + + m := InitModule(ctx, enr) + assert.NotNil(t, m) + + m.Reconcile(ctx) + + testFlow := &flow.Flow{ + IP: &flow.IP{Source: "1.1.1.1"}, + Source: &flow.Endpoint{ + Namespace: "default", + PodName: "test-pod", + }, + } + + event := &v1.Event{Event: testFlow} + for i := 0; i < 2; i++ { + testRing.Write(event) + time.Sleep(25 * time.Millisecond) + } + + mfs, err := exporter.AdvancedRegistry.Gather() + assert.NoError(t, err) + var validMetricCount int + + for _, mf := range mfs { + if !strings.Contains(mf.GetName(), metrics.HNSStats) { + continue + } + t.Logf("Metric Family: %s", mf.GetName()) + + for _, m := range mf.GetMetric() { + labelMap := map[string]string{} + for _, label := range m.GetLabel() { + labelMap[label.GetName()] = label.GetValue() + } + assert.Equal(t, "1.1.1.1", labelMap["ip"]) + assert.Equal(t, "default", labelMap["namespace"]) + assert.Equal(t, "test-pod", labelMap["podname"]) + assert.Equal(t, "", labelMap["workload_kind"]) + assert.Equal(t, "", labelMap["workload_name"]) + + if labelMap["direction"] == mm.PacketsReceived { + assert.Equal(t, float64(42), m.GetGauge().GetValue()) + validMetricCount++ + } else { + assert.Equal(t, float64(99), m.GetGauge().GetValue()) + validMetricCount++ + } + } + } + assert.Equal(t, 2, validMetricCount, "Expected 2 metric samples with correct labels and values") +} diff --git a/pkg/module/metrics/tcp.go b/pkg/module/metrics/tcp.go new file mode 100644 index 0000000000..8da8b70ae4 --- /dev/null +++ b/pkg/module/metrics/tcp.go @@ -0,0 +1,95 @@ +package metrics + +import ( + "strings" + + v1 "github.com/cilium/cilium/api/v1/flow" + api "github.com/microsoft/retina/crd/api/v1alpha1" + "github.com/microsoft/retina/pkg/exporter" + "github.com/microsoft/retina/pkg/log" + metricsinit "github.com/microsoft/retina/pkg/metrics" + "github.com/microsoft/retina/pkg/utils" + "go.uber.org/zap" +) + +const ( + // Metric names + TCPConnectionStatsName = "adv_tcp_connection_stats" + + // Metric descriptions + TCPConnectionStatsGaugeDescription = "TCP connection statistics" +) + +type TCPConnectionMetrics struct { + baseMetricObject + tcpConnStatsGauge metricsinit.GaugeVec + metricName string +} + +func NewTCPConnectionMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isLocalContext enrichmentContext) *TCPConnectionMetrics { + if ctxOptions == nil || !strings.Contains(strings.ToLower(ctxOptions.MetricName), "tcp_connection") { + return nil + } + + fl = fl.Named("tcpconnection-metricsmodule") + fl.Info("Creating TCP Connection Stats metrics", zap.Any("options", ctxOptions)) + return &TCPConnectionMetrics{ + baseMetricObject: newBaseMetricsObject(ctxOptions, fl, isLocalContext), + } +} + +func (t *TCPConnectionMetrics) Init(metricName string) { + t.tcpConnStatsGauge = exporter.CreatePrometheusGaugeVecForMetric( + exporter.AdvancedRegistry, + TCPConnectionStatsName, + TCPConnectionStatsGaugeDescription, + t.getLabels()..., + ) + t.metricName = metricName +} + +func (t *TCPConnectionMetrics) getLabels() []string { + labels := []string{ + utils.StatName, + } + + if t.srcCtx != nil { + labels = append(labels, t.srcCtx.getLabels()...) + t.l.Info("src labels", zap.Any("labels", labels)) + } + + if t.dstCtx != nil { + labels = append(labels, t.dstCtx.getLabels()...) + t.l.Info("dst labels", zap.Any("labels", labels)) + } + + return labels +} + +func (t *TCPConnectionMetrics) ProcessFlow(flow *v1.Flow) { + if flow == nil || GetHNSMetadata(flow).VfpPortStatsData == nil { + return + } + + // label values + lbls := []string{ + flow.GetIP().Source, + flow.Source.Namespace, + flow.Source.PodName, + "", + "", + } + + t.tcpConnStatsGauge.WithLabelValues(append([]string{utils.ResetCount}, lbls...)...).Set(float64(GetHNSMetadata(flow).VfpPortStatsData.In.TcpCounters.ConnectionCounters.ResetCount)) + t.tcpConnStatsGauge.WithLabelValues(append([]string{utils.ClosedFin}, lbls...)...).Set(float64(GetHNSMetadata(flow).VfpPortStatsData.In.TcpCounters.ConnectionCounters.ClosedFinCount)) + t.tcpConnStatsGauge.WithLabelValues(append([]string{utils.ResetSyn}, lbls...)...).Set(float64(GetHNSMetadata(flow).VfpPortStatsData.In.TcpCounters.ConnectionCounters.ResetSynCount)) + t.tcpConnStatsGauge.WithLabelValues(append([]string{utils.TcpHalfOpenTimeouts}, lbls...)...).Set(float64(GetHNSMetadata(flow).VfpPortStatsData.In.TcpCounters.ConnectionCounters.TcpHalfOpenTimeoutsCount)) + t.tcpConnStatsGauge.WithLabelValues(append([]string{utils.Verified}, lbls...)...).Set(float64(GetHNSMetadata(flow).VfpPortStatsData.In.TcpCounters.ConnectionCounters.VerifiedCount)) + t.tcpConnStatsGauge.WithLabelValues(append([]string{utils.TimedOutCount}, lbls...)...).Set(float64(GetHNSMetadata(flow).VfpPortStatsData.In.TcpCounters.ConnectionCounters.TimedOutCount)) + t.tcpConnStatsGauge.WithLabelValues(append([]string{utils.TimeWaitExpiredCount}, lbls...)...).Set(float64(GetHNSMetadata(flow).VfpPortStatsData.In.TcpCounters.ConnectionCounters.TimeWaitExpiredCount)) +} + +func (t *TCPConnectionMetrics) Clean() { + t.l.Info("Cleaning metric", zap.String("name", t.metricName)) + exporter.UnregisterMetric(exporter.AdvancedRegistry, metricsinit.ToPrometheusType(t.tcpConnStatsGauge)) +} diff --git a/pkg/module/metrics/tcp_test.go b/pkg/module/metrics/tcp_test.go new file mode 100644 index 0000000000..a1ecebd7e1 --- /dev/null +++ b/pkg/module/metrics/tcp_test.go @@ -0,0 +1,106 @@ +package metrics + +import ( + "strings" + "testing" + + "github.com/cilium/cilium/api/v1/flow" + "github.com/microsoft/retina/crd/api/v1alpha1" + "github.com/microsoft/retina/pkg/exporter" + "github.com/microsoft/retina/pkg/log" + "github.com/microsoft/retina/pkg/utils" + "github.com/stretchr/testify/assert" +) + +func TestTCPConnectionMetrics(t *testing.T) { + logger, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + ctxOptions := &v1alpha1.MetricsContextOptions{ + MetricName: TCPConnectionStatsName, + SourceLabels: append([]string{utils.StatName}, DefaultCtxOptions()...), + } + + tcp := NewTCPConnectionMetrics(ctxOptions, logger, LocalContext) + tcp.Init(ctxOptions.MetricName) + + originalGetHNS := GetHNSMetadata + GetHNSMetadata = func(flow *flow.Flow) *utils.HNSStatsMetadata { + return &utils.HNSStatsMetadata{ + VfpPortStatsData: &utils.VfpPortStatsData{ + In: &utils.VfpDirectedPortCounters{ + TcpCounters: &utils.VfpTcpStats{ + ConnectionCounters: &utils.VfpTcpConnectionStats{ + VerifiedCount: 10, + TimedOutCount: 20, + ResetCount: 30, + ResetSynCount: 40, + ClosedFinCount: 50, + TcpHalfOpenTimeoutsCount: 60, + TimeWaitExpiredCount: 70, + }, + }, + }, + }, + } + } + defer func() { GetHNSMetadata = originalGetHNS }() + + testFlow := &flow.Flow{ + IP: &flow.IP{Source: "1.1.1.1"}, + Source: &flow.Endpoint{ + Namespace: "default", + PodName: "test-pod", + }, + } + + tcp.ProcessFlow(testFlow) + + mfs, err := exporter.AdvancedRegistry.Gather() + assert.NoError(t, err) + var validMetricCount int + + for _, mf := range mfs { + if !strings.Contains(mf.GetName(), TCPConnectionStatsName) { + continue + } + t.Logf("Metric Family: %s", mf.GetName()) + + for _, m := range mf.GetMetric() { + labelMap := map[string]string{} + for _, label := range m.GetLabel() { + labelMap[label.GetName()] = label.GetValue() + } + assert.Equal(t, "1.1.1.1", labelMap["ip"]) + assert.Equal(t, "default", labelMap["namespace"]) + assert.Equal(t, "test-pod", labelMap["podname"]) + assert.Equal(t, "", labelMap["workload_kind"]) + assert.Equal(t, "", labelMap["workload_name"]) + + if labelMap[utils.StatName] == utils.Verified { + assert.Equal(t, float64(10), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap[utils.StatName] == utils.TimedOutCount { + assert.Equal(t, float64(20), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap[utils.StatName] == utils.ResetCount { + assert.Equal(t, float64(30), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap[utils.StatName] == utils.ResetSyn { + assert.Equal(t, float64(40), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap[utils.StatName] == utils.ClosedFin { + assert.Equal(t, float64(50), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap[utils.StatName] == utils.TcpHalfOpenTimeouts { + assert.Equal(t, float64(60), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap[utils.StatName] == utils.TimeWaitExpiredCount { + assert.Equal(t, float64(70), m.GetGauge().GetValue()) + validMetricCount++ + } + } + } + + assert.Equal(t, 7, validMetricCount, "Expected 7 metric samples with correct labels and values") +} diff --git a/pkg/module/metrics/tcpflags.go b/pkg/module/metrics/tcpflags.go index c6a24a8635..9a617087e4 100644 --- a/pkg/module/metrics/tcpflags.go +++ b/pkg/module/metrics/tcpflags.go @@ -25,10 +25,12 @@ const ( type TCPMetrics struct { baseMetricObject - tcpFlagsMetrics metricsinit.GaugeVec + tcpFlagsMetrics metricsinit.GaugeVec + metricName string + enableStandalone bool } -func NewTCPMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isLocalContext enrichmentContext) *TCPMetrics { +func NewTCPMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isLocalContext enrichmentContext, enableStandalone bool) *TCPMetrics { if ctxOptions == nil || !strings.Contains(strings.ToLower(ctxOptions.MetricName), "flag") { return nil } @@ -37,6 +39,7 @@ func NewTCPMetrics(ctxOptions *api.MetricsContextOptions, fl *log.ZapLogger, isL fl.Info("Creating TCP Flags count metrics", zap.Any("options", ctxOptions)) return &TCPMetrics{ baseMetricObject: newBaseMetricsObject(ctxOptions, fl, isLocalContext), + enableStandalone: enableStandalone, } } @@ -48,18 +51,26 @@ func (t *TCPMetrics) Init(metricName string) { TCPFlagsCountDesc, t.getLabels()..., ) + t.metricName = metricName } func (t *TCPMetrics) getLabels() []string { labels := []string{ utils.Flag, } + + if t.enableStandalone { + labels = append(labels, utils.Direction) + } + if t.srcCtx != nil { labels = append(labels, t.srcCtx.getLabels()...) + t.l.Info("src labels", zap.Any("labels", labels)) } if t.dstCtx != nil { labels = append(labels, t.dstCtx.getLabels()...) + t.l.Info("dst labels", zap.Any("labels", labels)) } return labels @@ -91,6 +102,11 @@ func (t *TCPMetrics) ProcessFlow(flow *v1.Flow) { return } + if t.enableStandalone { + t.processStandaloneFlow(flow) + return + } + if flow.Verdict != v1.Verdict_FORWARDED { return } @@ -155,6 +171,42 @@ func (t *TCPMetrics) processLocalCtxFlow(flow *v1.Flow, flags []string) { } } +func (t *TCPMetrics) processStandaloneFlow(fl *v1.Flow) { + if GetHNSMetadata(fl).VfpPortStatsData == nil { + return + } + + // ingress values + ingressLbls := []string{ + ingress, + fl.GetIP().Source, + fl.Source.Namespace, + fl.Source.PodName, + "", + "", + } + + // egress values + egressLbls := []string{ + egress, + fl.GetIP().Source, + fl.Source.Namespace, + fl.Source.PodName, + "", + "", + } + + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.SYN}, ingressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.In.TcpCounters.PacketCounters.SynPacketCount)) + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.SYNACK}, ingressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.In.TcpCounters.PacketCounters.SynAckPacketCount)) + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.FIN}, ingressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.In.TcpCounters.PacketCounters.FinPacketCount)) + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.RST}, ingressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.In.TcpCounters.PacketCounters.RstPacketCount)) + + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.SYN}, egressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.Out.TcpCounters.PacketCounters.SynPacketCount)) + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.SYNACK}, egressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.Out.TcpCounters.PacketCounters.SynAckPacketCount)) + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.FIN}, egressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.Out.TcpCounters.PacketCounters.FinPacketCount)) + t.tcpFlagsMetrics.WithLabelValues(append([]string{utils.RST}, egressLbls...)...).Set(float64(GetHNSMetadata(fl).VfpPortStatsData.Out.TcpCounters.PacketCounters.RstPacketCount)) +} + func (t *TCPMetrics) getFlagValues(flags *v1.TCPFlags) []string { f := make([]string, 0) if flags == nil { @@ -203,5 +255,6 @@ func (t *TCPMetrics) getFlagValues(flags *v1.TCPFlags) []string { } func (t *TCPMetrics) Clean() { + t.l.Info("Cleaning metric", zap.String("name", t.metricName)) exporter.UnregisterMetric(exporter.AdvancedRegistry, metricsinit.ToPrometheusType(t.tcpFlagsMetrics)) } diff --git a/pkg/module/metrics/tcpflags_test.go b/pkg/module/metrics/tcpflags_test.go index 8b845df6bb..6be59aca00 100644 --- a/pkg/module/metrics/tcpflags_test.go +++ b/pkg/module/metrics/tcpflags_test.go @@ -5,12 +5,15 @@ package metrics import ( + "strings" "testing" "github.com/cilium/cilium/api/v1/flow" "github.com/microsoft/retina/crd/api/v1alpha1" + "github.com/microsoft/retina/pkg/exporter" "github.com/microsoft/retina/pkg/log" metricsinit "github.com/microsoft/retina/pkg/metrics" + "github.com/microsoft/retina/pkg/utils" "github.com/prometheus/client_golang/prometheus" "github.com/stretchr/testify/assert" "go.uber.org/mock/gomock" @@ -382,7 +385,7 @@ func TestNewTCPMetrics(t *testing.T) { "service", "port", }, - localContext: localContext, + localContext: LocalContext, metricCall: 7, }, { @@ -421,7 +424,7 @@ func TestNewTCPMetrics(t *testing.T) { "service", "port", }, - localContext: localContext, + localContext: LocalContext, metricCall: 0, }, { @@ -462,7 +465,7 @@ func TestNewTCPMetrics(t *testing.T) { "service", "port", }, - localContext: localContext, + localContext: LocalContext, metricCall: 14, }, } @@ -471,7 +474,7 @@ func TestNewTCPMetrics(t *testing.T) { log.Logger().Info("Running test name", zap.String("name", tc.name)) ctrl := gomock.NewController(t) - tcp := NewTCPMetrics(tc.opts, log.Logger(), tc.localContext) + tcp := NewTCPMetrics(tc.opts, log.Logger(), tc.localContext, false) if tc.nilObj { assert.Nil(t, tcp, "forward metrics should be nil Test Name: %s", tc.name) continue @@ -495,3 +498,106 @@ func TestNewTCPMetrics(t *testing.T) { ctrl.Finish() } } + +func TestStandaloneTCPFlagsMetrics(t *testing.T) { + logger, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + ctxOptions := &v1alpha1.MetricsContextOptions{ + MetricName: TCPFlagsCountName, + SourceLabels: append([]string{utils.Flag, utils.Direction}, DefaultCtxOptions()...), + } + + tcp := NewTCPMetrics(ctxOptions, logger, LocalContext, true) + tcp.Init(ctxOptions.MetricName) + + originalGetHNS := GetHNSMetadata + GetHNSMetadata = func(flow *flow.Flow) *utils.HNSStatsMetadata { + return &utils.HNSStatsMetadata{ + VfpPortStatsData: &utils.VfpPortStatsData{ + In: &utils.VfpDirectedPortCounters{ + TcpCounters: &utils.VfpTcpStats{ + PacketCounters: &utils.VfpTcpPacketStats{ + SynPacketCount: 10, + SynAckPacketCount: 20, + FinPacketCount: 30, + RstPacketCount: 40, + }, + }, + }, + Out: &utils.VfpDirectedPortCounters{ + TcpCounters: &utils.VfpTcpStats{ + PacketCounters: &utils.VfpTcpPacketStats{ + SynPacketCount: 50, + SynAckPacketCount: 60, + FinPacketCount: 70, + RstPacketCount: 80, + }, + }, + }, + }, + } + } + defer func() { GetHNSMetadata = originalGetHNS }() + + testFlow := &flow.Flow{ + IP: &flow.IP{Source: "1.1.1.1"}, + Source: &flow.Endpoint{ + Namespace: "default", + PodName: "test-pod", + }, + } + + tcp.ProcessFlow(testFlow) + + mfs, err := exporter.AdvancedRegistry.Gather() + assert.NoError(t, err) + var validMetricCount int + + for _, mf := range mfs { + if !strings.Contains(mf.GetName(), TCPFlagsCountName) { + continue + } + t.Logf("Metric Family: %s", mf.GetName()) + + for _, m := range mf.GetMetric() { + labelMap := map[string]string{} + for _, label := range m.GetLabel() { + labelMap[label.GetName()] = label.GetValue() + } + assert.Equal(t, "1.1.1.1", labelMap["ip"]) + assert.Equal(t, "default", labelMap["namespace"]) + assert.Equal(t, "test-pod", labelMap["podname"]) + assert.Equal(t, "", labelMap["workload_kind"]) + assert.Equal(t, "", labelMap["workload_name"]) + + if labelMap["direction"] == "ingress" && labelMap["flag"] == utils.SYN { + assert.Equal(t, float64(10), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "ingress" && labelMap["flag"] == utils.SYNACK { + assert.Equal(t, float64(20), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "ingress" && labelMap["flag"] == utils.FIN { + assert.Equal(t, float64(30), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "ingress" && labelMap["flag"] == utils.RST { + assert.Equal(t, float64(40), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "egress" && labelMap["flag"] == utils.SYN { + assert.Equal(t, float64(50), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "egress" && labelMap["flag"] == utils.SYNACK { + assert.Equal(t, float64(60), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "egress" && labelMap["flag"] == utils.FIN { + assert.Equal(t, float64(70), m.GetGauge().GetValue()) + validMetricCount++ + } else if labelMap["direction"] == "egress" && labelMap["flag"] == utils.RST { + assert.Equal(t, float64(80), m.GetGauge().GetValue()) + validMetricCount++ + } + } + } + + assert.Equal(t, 8, validMetricCount, "Expected 8 metric samples with correct labels and values") +} diff --git a/pkg/module/metrics/types.go b/pkg/module/metrics/types.go index 41d923a661..fddafe09d2 100644 --- a/pkg/module/metrics/types.go +++ b/pkg/module/metrics/types.go @@ -10,6 +10,7 @@ import ( "github.com/cilium/cilium/api/v1/flow" api "github.com/microsoft/retina/crd/api/v1alpha1" "github.com/microsoft/retina/pkg/common" + "github.com/microsoft/retina/pkg/metrics" "github.com/microsoft/retina/pkg/utils" ) @@ -44,9 +45,9 @@ const ( // workload context option workloadCtxOption = "workload" - // localContext means only the pods on this node will be watched + // LocalContext means only the pods on this node will be watched // and only these events will be enriched - localContext enrichmentContext = "local" + LocalContext enrichmentContext = "local" // remoteContext means all pods on the cluster will be watched // and events will be enriched @@ -330,6 +331,23 @@ func DefaultCtxOptions() []string { } } +// DefaultStandaloneMetrics used for standalone mode (windows only) +func DefaultStandaloneMetrics() []string { + return []string{ + // forward + utils.ForwardPacketsGaugeName, + utils.ForwardBytesGaugeName, + // hns + metrics.HNSStats, + // drop + utils.DroppedPacketsGaugeName, + // tcp connections + utils.TCPConnectionStatsName, + // tcp flags + utils.TCPFlagGauge, + } +} + // DefaultMetrics used for enableAnnotations where it sets enabled advanced metrics // so users will not have to manually define. // For any new advanced metrics we want to have enabled by default for annotation based solution, add it here. diff --git a/pkg/plugin/ciliumeventobserver/ciliumeventobserver_linux_test.go b/pkg/plugin/ciliumeventobserver/ciliumeventobserver_linux_test.go index 92eec5ce1f..7f4400c1fa 100644 --- a/pkg/plugin/ciliumeventobserver/ciliumeventobserver_linux_test.go +++ b/pkg/plugin/ciliumeventobserver/ciliumeventobserver_linux_test.go @@ -28,7 +28,7 @@ func TestStartError(t *testing.T) { _, _ = log.SetupZapLogger(log.GetDefaultLogOpts()) c := cache.New(pubsub.New()) - e := enricher.New(ctxTimeout, c) + e := enricher.New(ctxTimeout, c, false) e.Run() defer e.Reader.Close() diff --git a/pkg/plugin/dns/dns_linux_test.go b/pkg/plugin/dns/dns_linux_test.go index 397c10dc55..9577065a90 100644 --- a/pkg/plugin/dns/dns_linux_test.go +++ b/pkg/plugin/dns/dns_linux_test.go @@ -54,7 +54,7 @@ func TestStart(t *testing.T) { log.SetupZapLogger(log.GetDefaultLogOpts()) c := cache.New(pubsub.New()) - e := enricher.New(ctxTimeout, c) + e := enricher.New(ctxTimeout, c, false) e.Run() defer e.Reader.Close() diff --git a/pkg/plugin/hnsstats/hnsstats_windows.go b/pkg/plugin/hnsstats/hnsstats_windows.go index 5a9ff3bae4..2e44147118 100644 --- a/pkg/plugin/hnsstats/hnsstats_windows.go +++ b/pkg/plugin/hnsstats/hnsstats_windows.go @@ -8,10 +8,12 @@ import ( "context" "encoding/json" "fmt" + "net" "time" "github.com/Microsoft/hcsshim" "github.com/Microsoft/hcsshim/hcn" + "github.com/cilium/cilium/api/v1/flow" v1 "github.com/cilium/cilium/pkg/hubble/api/v1" kcfg "github.com/microsoft/retina/pkg/config" "github.com/microsoft/retina/pkg/enricher" @@ -19,6 +21,7 @@ import ( "github.com/microsoft/retina/pkg/metrics" "github.com/microsoft/retina/pkg/plugin/registry" "github.com/microsoft/retina/pkg/utils" + "go.uber.org/zap" ) @@ -82,14 +85,9 @@ func (h *hnsstats) Init() error { // Filter out any endpoints that are not in "AttachedShared" State. All running Windows pods with networking must be in this state. var filterMap map[string]uint16 if h.cfg.EnableStandalone { - if instance := enricher.StandaloneInstance(); instance != nil { - InitializeAdvancedMetrics() - h.l.Info("Metrics initialized") - - h.enricher = enricher.StandaloneInstance() + if enricher.IsInitialized() { + h.enricher = enricher.Instance() h.l.Info("Standalone enricher is enabled") - } else { - h.l.Warn("Standalone enricher is not initialized") } } else { filterMap = map[string]uint16{"State": HCN_ENDPOINT_STATE_ATTACHED_SHARING} @@ -141,13 +139,6 @@ func pullHnsStats(ctx context.Context, h *hnsstats) error { mac := ep.MacAddress ip := ep.IpConfigurations[0].IpAddress - if h.cfg.EnableStandalone { - if err = h.enricher.PublishEvent(ip, enricher.AddEvent); err != nil { - h.l.Error("Failed to publish event", zap.String(zapIPField, ip), zap.Error(err)) - continue - } - } - if stats, err := hcsshim.GetHNSEndpointStats(id); err != nil { h.l.Error("Getting endpoint stats failed", zap.String(zapEndpointIDField, id), zap.Error(err)) } else { @@ -175,69 +166,43 @@ func pullHnsStats(ctx context.Context, h *hnsstats) error { h.l.Error("Unable to find VFP port counters", zap.String(zapMACField, mac), zap.String(zapPortField, portguid), zap.Error(err)) } + if h.cfg.EnableStandalone { + h.sendFlow(ip, hnsStatsData) + } notifyHnsStats(h, hnsStatsData) } } - - if h.cfg.EnableStandalone { - h.enricher.RemoveStaleEntries() - } } } } -func notifyHnsStats(h *hnsstats, stats *HnsStatsData) { - if h.cfg.EnableStandalone { - labels := h.enricher.GetPodInfo(stats.IPAddress) - - if labels == nil { - h.l.Debug("No labels found for IP", zap.String(zapIPField, stats.IPAddress)) - return - } - - updateMetric(AdvForwardPacketsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsReceived, ingressLabel) - h.l.Debug("emitting packets received count metric", zap.Uint64(PacketsReceived, stats.hnscounters.PacketsReceived)) - updateMetric(AdvForwardPacketsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsSent, egressLabel) - h.l.Debug("emitting packets sent count metric", zap.Uint64(PacketsSent, stats.hnscounters.PacketsSent)) - updateMetric(AdvForwardBytesGauge, stats.IPAddress, labels, stats.hnscounters.BytesReceived, ingressLabel) - h.l.Debug("emitting bytes received count metric", zap.Uint64(BytesReceived, stats.hnscounters.BytesReceived)) - updateMetric(AdvForwardBytesGauge, stats.IPAddress, labels, stats.hnscounters.BytesSent, egressLabel) - h.l.Debug("emitting bytes sent count metric", zap.Uint64(BytesSent, stats.hnscounters.BytesSent)) - - updateMetric(AdvHNSStatsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsReceived, PacketsReceived) - updateMetric(AdvHNSStatsGauge, stats.IPAddress, labels, stats.hnscounters.PacketsSent, PacketsSent) - - updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.hnscounters.DroppedPacketsOutgoing, utils.Endpoint, egressLabel) - updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.hnscounters.DroppedPacketsIncoming, utils.Endpoint, ingressLabel) - - if stats.vfpCounters == nil { - h.l.Debug("will not record some metrics since VFP port counters failed to be set") - return - } - - updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.vfpCounters.In.DropCounters.AclDropPacketCount, utils.AclRule, ingressLabel) - updateMetric(AdvDroppedPacketsGauge, stats.IPAddress, labels, stats.vfpCounters.Out.DropCounters.AclDropPacketCount, utils.AclRule, egressLabel) - - updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.ResetCount, utils.ResetCount) - updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.ClosedFinCount, utils.ClosedFin) - updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.ResetSynCount, utils.ResetSyn) - updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.TcpHalfOpenTimeoutsCount, utils.TcpHalfOpenTimeouts) - updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.VerifiedCount, utils.Verified) - updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.TimedOutCount, utils.TimedOutCount) - updateMetric(AdvTCPConnectionStatsGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.ConnectionCounters.TimeWaitExpiredCount, utils.TimeWaitExpiredCount) - // TCP Flag counters - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.SynPacketCount, ingressLabel, utils.SYN) - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.SynAckPacketCount, ingressLabel, utils.SYNACK) - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.FinPacketCount, ingressLabel, utils.FIN) - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.In.TcpCounters.PacketCounters.RstPacketCount, ingressLabel, utils.RST) - - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.SynPacketCount, egressLabel, utils.SYN) - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.SynAckPacketCount, egressLabel, utils.SYNACK) - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.FinPacketCount, egressLabel, utils.FIN) - updateMetric(AdvTCPFlagGauge, stats.IPAddress, labels, stats.vfpCounters.Out.TcpCounters.PacketCounters.RstPacketCount, egressLabel, utils.RST) - return +func (h *hnsstats) sendFlow(ip string, hnsstatsData *HnsStatsData) { + fl := utils.ToFlow( + h.l, + time.Now().UnixNano(), + net.ParseIP(ip), + nil, + uint32(0), + uint32(0), + uint8(0), + uint8(0), + flow.Verdict_VERDICT_UNKNOWN, + ) + + hnsstats := &utils.HNSStatsMetadata{} + utils.AddCounters(hnsstats, toEndpointStats(hnsstatsData.hnscounters), toVfpPortCounters(hnsstatsData.vfpCounters)) + utils.AddHNSMetadata(fl, hnsstats) + + ev := &v1.Event{ + Event: fl, + Timestamp: fl.GetTime(), } + if h.enricher != nil { + h.enricher.Write(ev) + } +} +func notifyHnsStats(h *hnsstats, stats *HnsStatsData) { // hns signals metrics.ForwardPacketsGauge.WithLabelValues(ingressLabel).Set(float64(stats.hnscounters.PacketsReceived)) h.l.Debug("emitting packets received count metric", zap.Uint64(PacketsReceived, stats.hnscounters.PacketsReceived)) @@ -298,10 +263,6 @@ func (h *hnsstats) Stop() error { return nil } - if h.cfg.EnableStandalone { - cleanAdvMetrics() - } - h.l.Info("Stopped listening for hnsstats event...") h.state = stop h.l.Info("Exiting hnsstats Stop...") diff --git a/pkg/plugin/hnsstats/types_windows.go b/pkg/plugin/hnsstats/types_windows.go index ed11a4b5ce..2452ce16fc 100644 --- a/pkg/plugin/hnsstats/types_windows.go +++ b/pkg/plugin/hnsstats/types_windows.go @@ -10,7 +10,6 @@ import ( "github.com/Microsoft/hcsshim" "github.com/Microsoft/hcsshim/hcn" kcfg "github.com/microsoft/retina/pkg/config" - "github.com/microsoft/retina/pkg/controllers/cache" "github.com/microsoft/retina/pkg/enricher" "github.com/microsoft/retina/pkg/exporter" "github.com/microsoft/retina/pkg/log" @@ -89,7 +88,7 @@ type hnsstats struct { state int l *log.ZapLogger endpointQuery hcn.HostComputeQuery - enricher *enricher.StandaloneEnricher + enricher *enricher.Enricher } type HnsStatsData struct { @@ -165,12 +164,71 @@ func (h *HnsStatsData) String() string { h.hnscounters.EndpointID, h.hnscounters.PacketsReceived, h.hnscounters.PacketsSent, h.hnscounters.BytesSent, h.hnscounters.BytesReceived) } -func InitializeAdvancedMetrics() { - if exporter.AdvancedRegistry != nil { - cleanAdvMetrics() - exporter.ResetAdvancedMetricsRegistry() +func toEndpointStats(h *hcsshim.HNSEndpointStats) *utils.EndpointStats { + return &utils.EndpointStats{ + BytesReceived: h.BytesReceived, + BytesSent: h.BytesSent, + DroppedPacketsIncoming: h.DroppedPacketsIncoming, + DroppedPacketsOutgoing: h.DroppedPacketsOutgoing, + EndpointID: h.EndpointID, + InstanceID: h.InstanceID, + PacketsReceived: h.PacketsReceived, + PacketsSent: h.PacketsSent, } +} + +func toVfpPortCounters(vfpCounters *VfpPortStatsData) *utils.VfpPortStatsData { + return &utils.VfpPortStatsData{ + In: &utils.VfpDirectedPortCounters{ + Direction: utils.VfpDirection_IN, + TcpCounters: &utils.VfpTcpStats{ + ConnectionCounters: &utils.VfpTcpConnectionStats{ + VerifiedCount: vfpCounters.In.TcpCounters.ConnectionCounters.VerifiedCount, + TimedOutCount: vfpCounters.In.TcpCounters.ConnectionCounters.TimedOutCount, + ResetCount: vfpCounters.In.TcpCounters.ConnectionCounters.ResetCount, + ResetSynCount: vfpCounters.In.TcpCounters.ConnectionCounters.ResetSynCount, + ClosedFinCount: vfpCounters.In.TcpCounters.ConnectionCounters.ClosedFinCount, + TcpHalfOpenTimeoutsCount: vfpCounters.In.TcpCounters.ConnectionCounters.TcpHalfOpenTimeoutsCount, + TimeWaitExpiredCount: vfpCounters.In.TcpCounters.ConnectionCounters.TimeWaitExpiredCount, + }, + PacketCounters: &utils.VfpTcpPacketStats{ + SynPacketCount: vfpCounters.In.TcpCounters.PacketCounters.SynPacketCount, + SynAckPacketCount: vfpCounters.In.TcpCounters.PacketCounters.SynAckPacketCount, + FinPacketCount: vfpCounters.In.TcpCounters.PacketCounters.FinPacketCount, + RstPacketCount: vfpCounters.In.TcpCounters.PacketCounters.RstPacketCount, + }, + }, + DropCounters: &utils.VfpPacketDropStats{ + AclDropPacketCount: vfpCounters.In.DropCounters.AclDropPacketCount, + }, + }, + Out: &utils.VfpDirectedPortCounters{ + Direction: utils.VfpDirection_OUT, + TcpCounters: &utils.VfpTcpStats{ + ConnectionCounters: &utils.VfpTcpConnectionStats{ + VerifiedCount: vfpCounters.Out.TcpCounters.ConnectionCounters.VerifiedCount, + TimedOutCount: vfpCounters.Out.TcpCounters.ConnectionCounters.TimedOutCount, + ResetCount: vfpCounters.Out.TcpCounters.ConnectionCounters.ResetCount, + ResetSynCount: vfpCounters.Out.TcpCounters.ConnectionCounters.ResetSynCount, + ClosedFinCount: vfpCounters.Out.TcpCounters.ConnectionCounters.ClosedFinCount, + TcpHalfOpenTimeoutsCount: vfpCounters.Out.TcpCounters.ConnectionCounters.TcpHalfOpenTimeoutsCount, + TimeWaitExpiredCount: vfpCounters.Out.TcpCounters.ConnectionCounters.TimeWaitExpiredCount, + }, + PacketCounters: &utils.VfpTcpPacketStats{ + SynPacketCount: vfpCounters.Out.TcpCounters.PacketCounters.SynPacketCount, + SynAckPacketCount: vfpCounters.Out.TcpCounters.PacketCounters.SynAckPacketCount, + FinPacketCount: vfpCounters.Out.TcpCounters.PacketCounters.FinPacketCount, + RstPacketCount: vfpCounters.Out.TcpCounters.PacketCounters.RstPacketCount, + }, + }, + DropCounters: &utils.VfpPacketDropStats{ + AclDropPacketCount: vfpCounters.Out.DropCounters.AclDropPacketCount, + }, + }, + } +} +func InitializeAdvancedMetrics() { AdvForwardPacketsGauge = exporter.CreatePrometheusGaugeVecForMetric( exporter.AdvancedRegistry, m.TotalCountName, @@ -228,18 +286,8 @@ func InitializeAdvancedMetrics() { "pod", "namespace", ) -} - -func cleanAdvMetrics() { - exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvForwardPacketsGauge)) - exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvForwardBytesGauge)) - exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvHNSStatsGauge)) - exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvDroppedPacketsGauge)) - exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvTCPConnectionStatsGauge)) - exporter.UnregisterMetric(exporter.AdvancedRegistry, metrics.ToPrometheusType(AdvTCPFlagGauge)) -} -func updateMetric(gauge *prometheus.GaugeVec, ip string, podInfo *cache.PodInfo, value uint64, labels ...string) { - labels = append(labels, ip, podInfo.Name, podInfo.Namespace) - gauge.WithLabelValues(labels...).Set(float64(value)) + // func updateMetric(gauge *prometheus.GaugeVec, ip string, podInfo *cache.PodInfo, value uint64, labels ...string) { + // labels = append(labels, ip, podInfo.Name, podInfo.Namespace) + // gauge.WithLabelValues(labels...).Set(float64(value)) } diff --git a/pkg/utils/flow_utils.go b/pkg/utils/flow_utils.go index 1ad3b84c3b..f08f4b4f3f 100644 --- a/pkg/utils/flow_utils.go +++ b/pkg/utils/flow_utils.go @@ -133,6 +133,29 @@ func AddRetinaMetadata(f *flow.Flow, meta *RetinaMetadata) { f.Extensions = ext } +// AddHNSStats adds the HNS stats data to the flow's extension field +func AddHNSMetadata(f *flow.Flow, hnsStats *HNSStatsMetadata) { + ext, _ := anypb.New(hnsStats) + f.Extensions = ext +} + +func AddCounters(hnsMetadata *HNSStatsMetadata, endpointStats *EndpointStats, vfpStats *VfpPortStatsData) { + if hnsMetadata == nil { + return + } + hnsMetadata.EndpointStats = endpointStats + hnsMetadata.VfpPortStatsData = vfpStats +} + +func GetHNSMetadata(f *flow.Flow) *HNSStatsMetadata { + if f.Extensions == nil { + return nil + } + k := &HNSStatsMetadata{} //nolint:typecheck + f.Extensions.UnmarshalTo(k) //nolint:errcheck + return k +} + func AddTCPFlags(f *flow.Flow, syn, ack, fin, rst, psh, urg, ece, cwr, ns uint16) { if f.GetL4().GetTCP() == nil { return diff --git a/pkg/utils/metadata_linux.pb.go b/pkg/utils/metadata_linux.pb.go index 6914c0b3e3..7b2b6b18a1 100644 --- a/pkg/utils/metadata_linux.pb.go +++ b/pkg/utils/metadata_linux.pb.go @@ -1,8 +1,8 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 -// protoc v4.24.2 -// source: pkg/utils/metadata_linux.proto +// protoc-gen-go v1.25.0-devel +// protoc v3.14.0 +// source: metadata_linux.proto package utils @@ -53,11 +53,11 @@ func (x DNSType) String() string { } func (DNSType) Descriptor() protoreflect.EnumDescriptor { - return file_pkg_utils_metadata_linux_proto_enumTypes[0].Descriptor() + return file_metadata_linux_proto_enumTypes[0].Descriptor() } func (DNSType) Type() protoreflect.EnumType { - return &file_pkg_utils_metadata_linux_proto_enumTypes[0] + return &file_metadata_linux_proto_enumTypes[0] } func (x DNSType) Number() protoreflect.EnumNumber { @@ -66,7 +66,7 @@ func (x DNSType) Number() protoreflect.EnumNumber { // Deprecated: Use DNSType.Descriptor instead. func (DNSType) EnumDescriptor() ([]byte, []int) { - return file_pkg_utils_metadata_linux_proto_rawDescGZIP(), []int{0} + return file_metadata_linux_proto_rawDescGZIP(), []int{0} } // Ref: pkg/plugin/dropreason/_cprog/drop_reason.h. @@ -115,11 +115,11 @@ func (x DropReason) String() string { } func (DropReason) Descriptor() protoreflect.EnumDescriptor { - return file_pkg_utils_metadata_linux_proto_enumTypes[1].Descriptor() + return file_metadata_linux_proto_enumTypes[1].Descriptor() } func (DropReason) Type() protoreflect.EnumType { - return &file_pkg_utils_metadata_linux_proto_enumTypes[1] + return &file_metadata_linux_proto_enumTypes[1] } func (x DropReason) Number() protoreflect.EnumNumber { @@ -128,7 +128,54 @@ func (x DropReason) Number() protoreflect.EnumNumber { // Deprecated: Use DropReason.Descriptor instead. func (DropReason) EnumDescriptor() ([]byte, []int) { - return file_pkg_utils_metadata_linux_proto_rawDescGZIP(), []int{1} + return file_metadata_linux_proto_rawDescGZIP(), []int{1} +} + +// HNS stats for standalone +type VfpDirection int32 + +const ( + VfpDirection_OUT VfpDirection = 0 + VfpDirection_IN VfpDirection = 1 +) + +// Enum value maps for VfpDirection. +var ( + VfpDirection_name = map[int32]string{ + 0: "OUT", + 1: "IN", + } + VfpDirection_value = map[string]int32{ + "OUT": 0, + "IN": 1, + } +) + +func (x VfpDirection) Enum() *VfpDirection { + p := new(VfpDirection) + *p = x + return p +} + +func (x VfpDirection) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VfpDirection) Descriptor() protoreflect.EnumDescriptor { + return file_metadata_linux_proto_enumTypes[2].Descriptor() +} + +func (VfpDirection) Type() protoreflect.EnumType { + return &file_metadata_linux_proto_enumTypes[2] +} + +func (x VfpDirection) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use VfpDirection.Descriptor instead. +func (VfpDirection) EnumDescriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{2} } type RetinaMetadata struct { @@ -153,7 +200,7 @@ type RetinaMetadata struct { func (x *RetinaMetadata) Reset() { *x = RetinaMetadata{} if protoimpl.UnsafeEnabled { - mi := &file_pkg_utils_metadata_linux_proto_msgTypes[0] + mi := &file_metadata_linux_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -166,7 +213,7 @@ func (x *RetinaMetadata) String() string { func (*RetinaMetadata) ProtoMessage() {} func (x *RetinaMetadata) ProtoReflect() protoreflect.Message { - mi := &file_pkg_utils_metadata_linux_proto_msgTypes[0] + mi := &file_metadata_linux_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -179,7 +226,7 @@ func (x *RetinaMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use RetinaMetadata.ProtoReflect.Descriptor instead. func (*RetinaMetadata) Descriptor() ([]byte, []int) { - return file_pkg_utils_metadata_linux_proto_rawDescGZIP(), []int{0} + return file_metadata_linux_proto_rawDescGZIP(), []int{0} } func (x *RetinaMetadata) GetBytes() uint32 { @@ -238,101 +285,761 @@ func (x *RetinaMetadata) GetPreviouslyObservedTcpFlags() map[string]uint32 { return nil } -var File_pkg_utils_metadata_linux_proto protoreflect.FileDescriptor - -var file_pkg_utils_metadata_linux_proto_rawDesc = []byte{ - 0x0a, 0x1e, 0x70, 0x6b, 0x67, 0x2f, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2f, 0x6d, 0x65, 0x74, 0x61, - 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6c, 0x69, 0x6e, 0x75, 0x78, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x12, 0x05, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x22, 0x86, 0x04, 0x0a, 0x0e, 0x52, 0x65, 0x74, 0x69, - 0x6e, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, - 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, - 0x12, 0x29, 0x0a, 0x08, 0x64, 0x6e, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0e, 0x32, 0x0e, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x44, 0x4e, 0x53, 0x54, 0x79, - 0x70, 0x65, 0x52, 0x07, 0x64, 0x6e, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6e, - 0x75, 0x6d, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x0c, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, - 0x12, 0x15, 0x0a, 0x06, 0x74, 0x63, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x05, 0x74, 0x63, 0x70, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x0b, 0x64, 0x72, 0x6f, 0x70, 0x5f, - 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x75, - 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x52, - 0x0a, 0x64, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x1b, 0x70, - 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, - 0x52, 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x12, 0x3a, 0x0a, 0x19, 0x70, - 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x17, - 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x78, 0x0a, 0x1d, 0x70, 0x72, 0x65, 0x76, 0x69, - 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x74, - 0x63, 0x70, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, - 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x52, 0x65, 0x74, 0x69, 0x6e, 0x61, 0x4d, 0x65, 0x74, - 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, - 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, 0x73, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x1a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, - 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, - 0x73, 0x1a, 0x4d, 0x0a, 0x1f, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, - 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x45, - 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, - 0x2a, 0x2f, 0x0a, 0x07, 0x44, 0x4e, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, - 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x51, 0x55, 0x45, 0x52, - 0x59, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x52, 0x45, 0x53, 0x50, 0x4f, 0x4e, 0x53, 0x45, 0x10, - 0x02, 0x2a, 0xa5, 0x01, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, - 0x12, 0x15, 0x0a, 0x11, 0x49, 0x50, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x52, 0x55, 0x4c, 0x45, - 0x5f, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x49, 0x50, 0x54, 0x41, 0x42, - 0x4c, 0x45, 0x5f, 0x4e, 0x41, 0x54, 0x5f, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x01, 0x12, 0x15, 0x0a, - 0x11, 0x54, 0x43, 0x50, 0x5f, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x5f, 0x42, 0x41, 0x53, - 0x49, 0x43, 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x43, 0x50, 0x5f, 0x41, 0x43, 0x43, 0x45, - 0x50, 0x54, 0x5f, 0x42, 0x41, 0x53, 0x49, 0x43, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x54, 0x43, - 0x50, 0x5f, 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x5f, 0x42, 0x41, 0x53, 0x49, 0x43, 0x10, 0x04, 0x12, - 0x16, 0x0a, 0x12, 0x43, 0x4f, 0x4e, 0x4e, 0x54, 0x52, 0x41, 0x43, 0x4b, 0x5f, 0x41, 0x44, 0x44, - 0x5f, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, - 0x57, 0x4e, 0x5f, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x06, 0x42, 0x27, 0x5a, 0x25, 0x67, 0x69, 0x74, - 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, - 0x74, 0x2f, 0x72, 0x65, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x75, 0x74, 0x69, - 0x6c, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +type EndpointStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BytesReceived uint64 `protobuf:"varint,1,opt,name=BytesReceived,proto3" json:"BytesReceived,omitempty"` + BytesSent uint64 `protobuf:"varint,2,opt,name=BytesSent,proto3" json:"BytesSent,omitempty"` + DroppedPacketsIncoming uint64 `protobuf:"varint,3,opt,name=DroppedPacketsIncoming,proto3" json:"DroppedPacketsIncoming,omitempty"` + DroppedPacketsOutgoing uint64 `protobuf:"varint,4,opt,name=DroppedPacketsOutgoing,proto3" json:"DroppedPacketsOutgoing,omitempty"` + EndpointID string `protobuf:"bytes,5,opt,name=EndpointID,proto3" json:"EndpointID,omitempty"` + InstanceID string `protobuf:"bytes,6,opt,name=InstanceID,proto3" json:"InstanceID,omitempty"` + PacketsReceived uint64 `protobuf:"varint,7,opt,name=PacketsReceived,proto3" json:"PacketsReceived,omitempty"` + PacketsSent uint64 `protobuf:"varint,8,opt,name=PacketsSent,proto3" json:"PacketsSent,omitempty"` +} + +func (x *EndpointStats) Reset() { + *x = EndpointStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EndpointStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EndpointStats) ProtoMessage() {} + +func (x *EndpointStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EndpointStats.ProtoReflect.Descriptor instead. +func (*EndpointStats) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{1} +} + +func (x *EndpointStats) GetBytesReceived() uint64 { + if x != nil { + return x.BytesReceived + } + return 0 +} + +func (x *EndpointStats) GetBytesSent() uint64 { + if x != nil { + return x.BytesSent + } + return 0 +} + +func (x *EndpointStats) GetDroppedPacketsIncoming() uint64 { + if x != nil { + return x.DroppedPacketsIncoming + } + return 0 +} + +func (x *EndpointStats) GetDroppedPacketsOutgoing() uint64 { + if x != nil { + return x.DroppedPacketsOutgoing + } + return 0 +} + +func (x *EndpointStats) GetEndpointID() string { + if x != nil { + return x.EndpointID + } + return "" +} + +func (x *EndpointStats) GetInstanceID() string { + if x != nil { + return x.InstanceID + } + return "" +} + +func (x *EndpointStats) GetPacketsReceived() uint64 { + if x != nil { + return x.PacketsReceived + } + return 0 +} + +func (x *EndpointStats) GetPacketsSent() uint64 { + if x != nil { + return x.PacketsSent + } + return 0 +} + +type VfpTcpConnectionStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + VerifiedCount uint64 `protobuf:"varint,1,opt,name=VerifiedCount,proto3" json:"VerifiedCount,omitempty"` + TimedOutCount uint64 `protobuf:"varint,2,opt,name=TimedOutCount,proto3" json:"TimedOutCount,omitempty"` + ResetCount uint64 `protobuf:"varint,3,opt,name=ResetCount,proto3" json:"ResetCount,omitempty"` + ResetSynCount uint64 `protobuf:"varint,4,opt,name=ResetSynCount,proto3" json:"ResetSynCount,omitempty"` + ClosedFinCount uint64 `protobuf:"varint,5,opt,name=ClosedFinCount,proto3" json:"ClosedFinCount,omitempty"` + TcpHalfOpenTimeoutsCount uint64 `protobuf:"varint,6,opt,name=TcpHalfOpenTimeoutsCount,proto3" json:"TcpHalfOpenTimeoutsCount,omitempty"` + TimeWaitExpiredCount uint64 `protobuf:"varint,7,opt,name=TimeWaitExpiredCount,proto3" json:"TimeWaitExpiredCount,omitempty"` +} + +func (x *VfpTcpConnectionStats) Reset() { + *x = VfpTcpConnectionStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpTcpConnectionStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpTcpConnectionStats) ProtoMessage() {} + +func (x *VfpTcpConnectionStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpTcpConnectionStats.ProtoReflect.Descriptor instead. +func (*VfpTcpConnectionStats) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{2} +} + +func (x *VfpTcpConnectionStats) GetVerifiedCount() uint64 { + if x != nil { + return x.VerifiedCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetTimedOutCount() uint64 { + if x != nil { + return x.TimedOutCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetResetCount() uint64 { + if x != nil { + return x.ResetCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetResetSynCount() uint64 { + if x != nil { + return x.ResetSynCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetClosedFinCount() uint64 { + if x != nil { + return x.ClosedFinCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetTcpHalfOpenTimeoutsCount() uint64 { + if x != nil { + return x.TcpHalfOpenTimeoutsCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetTimeWaitExpiredCount() uint64 { + if x != nil { + return x.TimeWaitExpiredCount + } + return 0 +} + +type VfpTcpPacketStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SynPacketCount uint64 `protobuf:"varint,1,opt,name=SynPacketCount,proto3" json:"SynPacketCount,omitempty"` + SynAckPacketCount uint64 `protobuf:"varint,2,opt,name=SynAckPacketCount,proto3" json:"SynAckPacketCount,omitempty"` + FinPacketCount uint64 `protobuf:"varint,3,opt,name=FinPacketCount,proto3" json:"FinPacketCount,omitempty"` + RstPacketCount uint64 `protobuf:"varint,4,opt,name=RstPacketCount,proto3" json:"RstPacketCount,omitempty"` +} + +func (x *VfpTcpPacketStats) Reset() { + *x = VfpTcpPacketStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpTcpPacketStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpTcpPacketStats) ProtoMessage() {} + +func (x *VfpTcpPacketStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpTcpPacketStats.ProtoReflect.Descriptor instead. +func (*VfpTcpPacketStats) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{3} +} + +func (x *VfpTcpPacketStats) GetSynPacketCount() uint64 { + if x != nil { + return x.SynPacketCount + } + return 0 +} + +func (x *VfpTcpPacketStats) GetSynAckPacketCount() uint64 { + if x != nil { + return x.SynAckPacketCount + } + return 0 +} + +func (x *VfpTcpPacketStats) GetFinPacketCount() uint64 { + if x != nil { + return x.FinPacketCount + } + return 0 +} + +func (x *VfpTcpPacketStats) GetRstPacketCount() uint64 { + if x != nil { + return x.RstPacketCount + } + return 0 +} + +type VfpPacketDropStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AclDropPacketCount uint64 `protobuf:"varint,1,opt,name=AclDropPacketCount,proto3" json:"AclDropPacketCount,omitempty"` +} + +func (x *VfpPacketDropStats) Reset() { + *x = VfpPacketDropStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpPacketDropStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpPacketDropStats) ProtoMessage() {} + +func (x *VfpPacketDropStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpPacketDropStats.ProtoReflect.Descriptor instead. +func (*VfpPacketDropStats) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{4} +} + +func (x *VfpPacketDropStats) GetAclDropPacketCount() uint64 { + if x != nil { + return x.AclDropPacketCount + } + return 0 +} + +type VfpTcpStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ConnectionCounters *VfpTcpConnectionStats `protobuf:"bytes,1,opt,name=ConnectionCounters,proto3" json:"ConnectionCounters,omitempty"` + PacketCounters *VfpTcpPacketStats `protobuf:"bytes,2,opt,name=PacketCounters,proto3" json:"PacketCounters,omitempty"` +} + +func (x *VfpTcpStats) Reset() { + *x = VfpTcpStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpTcpStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpTcpStats) ProtoMessage() {} + +func (x *VfpTcpStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpTcpStats.ProtoReflect.Descriptor instead. +func (*VfpTcpStats) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{5} +} + +func (x *VfpTcpStats) GetConnectionCounters() *VfpTcpConnectionStats { + if x != nil { + return x.ConnectionCounters + } + return nil +} + +func (x *VfpTcpStats) GetPacketCounters() *VfpTcpPacketStats { + if x != nil { + return x.PacketCounters + } + return nil +} + +type VfpDirectedPortCounters struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Direction VfpDirection `protobuf:"varint,1,opt,name=direction,proto3,enum=utils.VfpDirection" json:"direction,omitempty"` + TcpCounters *VfpTcpStats `protobuf:"bytes,2,opt,name=TcpCounters,proto3" json:"TcpCounters,omitempty"` + DropCounters *VfpPacketDropStats `protobuf:"bytes,3,opt,name=DropCounters,proto3" json:"DropCounters,omitempty"` +} + +func (x *VfpDirectedPortCounters) Reset() { + *x = VfpDirectedPortCounters{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpDirectedPortCounters) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpDirectedPortCounters) ProtoMessage() {} + +func (x *VfpDirectedPortCounters) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpDirectedPortCounters.ProtoReflect.Descriptor instead. +func (*VfpDirectedPortCounters) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{6} +} + +func (x *VfpDirectedPortCounters) GetDirection() VfpDirection { + if x != nil { + return x.Direction + } + return VfpDirection_OUT +} + +func (x *VfpDirectedPortCounters) GetTcpCounters() *VfpTcpStats { + if x != nil { + return x.TcpCounters + } + return nil +} + +func (x *VfpDirectedPortCounters) GetDropCounters() *VfpPacketDropStats { + if x != nil { + return x.DropCounters + } + return nil +} + +type VfpPortStatsData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + In *VfpDirectedPortCounters `protobuf:"bytes,1,opt,name=In,proto3" json:"In,omitempty"` + Out *VfpDirectedPortCounters `protobuf:"bytes,2,opt,name=Out,proto3" json:"Out,omitempty"` +} + +func (x *VfpPortStatsData) Reset() { + *x = VfpPortStatsData{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpPortStatsData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpPortStatsData) ProtoMessage() {} + +func (x *VfpPortStatsData) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpPortStatsData.ProtoReflect.Descriptor instead. +func (*VfpPortStatsData) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{7} +} + +func (x *VfpPortStatsData) GetIn() *VfpDirectedPortCounters { + if x != nil { + return x.In + } + return nil +} + +func (x *VfpPortStatsData) GetOut() *VfpDirectedPortCounters { + if x != nil { + return x.Out + } + return nil +} + +type HNSStatsMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EndpointStats *EndpointStats `protobuf:"bytes,1,opt,name=EndpointStats,proto3" json:"EndpointStats,omitempty"` + VfpPortStatsData *VfpPortStatsData `protobuf:"bytes,2,opt,name=VfpPortStatsData,proto3" json:"VfpPortStatsData,omitempty"` +} + +func (x *HNSStatsMetadata) Reset() { + *x = HNSStatsMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_linux_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HNSStatsMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HNSStatsMetadata) ProtoMessage() {} + +func (x *HNSStatsMetadata) ProtoReflect() protoreflect.Message { + mi := &file_metadata_linux_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HNSStatsMetadata.ProtoReflect.Descriptor instead. +func (*HNSStatsMetadata) Descriptor() ([]byte, []int) { + return file_metadata_linux_proto_rawDescGZIP(), []int{8} +} + +func (x *HNSStatsMetadata) GetEndpointStats() *EndpointStats { + if x != nil { + return x.EndpointStats + } + return nil +} + +func (x *HNSStatsMetadata) GetVfpPortStatsData() *VfpPortStatsData { + if x != nil { + return x.VfpPortStatsData + } + return nil +} + +var File_metadata_linux_proto protoreflect.FileDescriptor + +var file_metadata_linux_proto_rawDesc = []byte{ + 0x0a, 0x14, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x6c, 0x69, 0x6e, 0x75, 0x78, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x22, 0x86, 0x04, + 0x0a, 0x0e, 0x52, 0x65, 0x74, 0x69, 0x6e, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, + 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x08, 0x64, 0x6e, 0x73, 0x5f, 0x74, 0x79, + 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0e, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, + 0x2e, 0x44, 0x4e, 0x53, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x64, 0x6e, 0x73, 0x54, 0x79, 0x70, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x75, 0x6d, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x12, 0x15, 0x0a, 0x06, 0x74, 0x63, 0x70, 0x5f, 0x69, 0x64, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x74, 0x63, 0x70, 0x49, 0x64, 0x12, 0x32, 0x0a, + 0x0b, 0x64, 0x72, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x52, + 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x52, 0x0a, 0x64, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x12, 0x3e, 0x0a, 0x1b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, + 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, + 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x73, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, + 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x0d, 0x52, 0x17, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, + 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x78, 0x0a, + 0x1d, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x64, 0x5f, 0x74, 0x63, 0x70, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x08, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x52, 0x65, 0x74, + 0x69, 0x6e, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x72, 0x65, 0x76, + 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, + 0x70, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x1a, 0x70, 0x72, 0x65, + 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, + 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x1a, 0x4d, 0x0a, 0x1f, 0x50, 0x72, 0x65, 0x76, 0x69, + 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, 0x70, + 0x46, 0x6c, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xcf, 0x02, 0x0a, 0x0d, 0x45, 0x6e, 0x64, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x0d, 0x42, 0x79, 0x74, 0x65, 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x12, 0x1c, + 0x0a, 0x09, 0x42, 0x79, 0x74, 0x65, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x09, 0x42, 0x79, 0x74, 0x65, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x12, 0x36, 0x0a, 0x16, + 0x44, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x49, 0x6e, + 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x16, 0x44, 0x72, + 0x6f, 0x70, 0x70, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x49, 0x6e, 0x63, 0x6f, + 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x36, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x73, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x12, 0x1e, 0x0a, 0x0a, + 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, + 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0a, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x12, 0x28, 0x0a, 0x0f, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, 0x65, + 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x73, 0x53, 0x65, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x22, 0xc1, 0x02, 0x0a, 0x15, 0x56, 0x66, 0x70, + 0x54, 0x63, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x64, 0x43, 0x6f, + 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x56, 0x65, 0x72, 0x69, 0x66, + 0x69, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x54, 0x69, 0x6d, 0x65, + 0x64, 0x4f, 0x75, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x64, 0x4f, 0x75, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x1e, + 0x0a, 0x0a, 0x52, 0x65, 0x73, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x0a, 0x52, 0x65, 0x73, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x24, + 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x79, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x79, 0x6e, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x46, 0x69, + 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x43, 0x6c, + 0x6f, 0x73, 0x65, 0x64, 0x46, 0x69, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3a, 0x0a, 0x18, + 0x54, 0x63, 0x70, 0x48, 0x61, 0x6c, 0x66, 0x4f, 0x70, 0x65, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x6f, + 0x75, 0x74, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x18, + 0x54, 0x63, 0x70, 0x48, 0x61, 0x6c, 0x66, 0x4f, 0x70, 0x65, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x6f, + 0x75, 0x74, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x32, 0x0a, 0x14, 0x54, 0x69, 0x6d, 0x65, + 0x57, 0x61, 0x69, 0x74, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x54, 0x69, 0x6d, 0x65, 0x57, 0x61, 0x69, 0x74, + 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xb9, 0x01, 0x0a, + 0x11, 0x56, 0x66, 0x70, 0x54, 0x63, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x53, 0x79, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x53, 0x79, 0x6e, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2c, 0x0a, 0x11, 0x53, 0x79, + 0x6e, 0x41, 0x63, 0x6b, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x53, 0x79, 0x6e, 0x41, 0x63, 0x6b, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x46, 0x69, 0x6e, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, + 0x52, 0x0e, 0x46, 0x69, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x26, 0x0a, 0x0e, 0x52, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x52, 0x73, 0x74, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x44, 0x0a, 0x12, 0x56, 0x66, 0x70, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x72, 0x6f, 0x70, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x2e, + 0x0a, 0x12, 0x41, 0x63, 0x6c, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x41, 0x63, 0x6c, 0x44, + 0x72, 0x6f, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x9d, + 0x01, 0x0a, 0x0b, 0x56, 0x66, 0x70, 0x54, 0x63, 0x70, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x4c, + 0x0a, 0x12, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, 0x74, 0x69, + 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x54, 0x63, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x12, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x12, 0x40, 0x0a, 0x0e, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, + 0x54, 0x63, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0e, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x22, 0xc1, + 0x01, 0x0a, 0x17, 0x56, 0x66, 0x70, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x6f, + 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x12, 0x31, 0x0a, 0x09, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x13, 0x2e, + 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x34, 0x0a, + 0x0b, 0x54, 0x63, 0x70, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x54, 0x63, + 0x70, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0b, 0x54, 0x63, 0x70, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x65, 0x72, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x74, 0x69, 0x6c, + 0x73, 0x2e, 0x56, 0x66, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x72, 0x6f, 0x70, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x52, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, + 0x72, 0x73, 0x22, 0x74, 0x0a, 0x10, 0x56, 0x66, 0x70, 0x50, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, + 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2e, 0x0a, 0x02, 0x49, 0x6e, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x44, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x6f, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, + 0x72, 0x73, 0x52, 0x02, 0x49, 0x6e, 0x12, 0x30, 0x0a, 0x03, 0x4f, 0x75, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x44, + 0x69, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x6f, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x65, 0x72, 0x73, 0x52, 0x03, 0x4f, 0x75, 0x74, 0x22, 0x93, 0x01, 0x0a, 0x10, 0x48, 0x4e, 0x53, + 0x53, 0x74, 0x61, 0x74, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x3a, 0x0a, + 0x0d, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x45, 0x6e, 0x64, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0d, 0x45, 0x6e, 0x64, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x43, 0x0a, 0x10, 0x56, 0x66, 0x70, + 0x50, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x50, + 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x10, 0x56, 0x66, + 0x70, 0x50, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, 0x2a, 0x2f, + 0x0a, 0x07, 0x44, 0x4e, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, + 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x51, 0x55, 0x45, 0x52, 0x59, 0x10, + 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x52, 0x45, 0x53, 0x50, 0x4f, 0x4e, 0x53, 0x45, 0x10, 0x02, 0x2a, + 0xa5, 0x01, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x15, + 0x0a, 0x11, 0x49, 0x50, 0x54, 0x41, 0x42, 0x4c, 0x45, 0x5f, 0x52, 0x55, 0x4c, 0x45, 0x5f, 0x44, + 0x52, 0x4f, 0x50, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x49, 0x50, 0x54, 0x41, 0x42, 0x4c, 0x45, + 0x5f, 0x4e, 0x41, 0x54, 0x5f, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x54, + 0x43, 0x50, 0x5f, 0x43, 0x4f, 0x4e, 0x4e, 0x45, 0x43, 0x54, 0x5f, 0x42, 0x41, 0x53, 0x49, 0x43, + 0x10, 0x02, 0x12, 0x14, 0x0a, 0x10, 0x54, 0x43, 0x50, 0x5f, 0x41, 0x43, 0x43, 0x45, 0x50, 0x54, + 0x5f, 0x42, 0x41, 0x53, 0x49, 0x43, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0f, 0x54, 0x43, 0x50, 0x5f, + 0x43, 0x4c, 0x4f, 0x53, 0x45, 0x5f, 0x42, 0x41, 0x53, 0x49, 0x43, 0x10, 0x04, 0x12, 0x16, 0x0a, + 0x12, 0x43, 0x4f, 0x4e, 0x4e, 0x54, 0x52, 0x41, 0x43, 0x4b, 0x5f, 0x41, 0x44, 0x44, 0x5f, 0x44, + 0x52, 0x4f, 0x50, 0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, + 0x5f, 0x44, 0x52, 0x4f, 0x50, 0x10, 0x06, 0x2a, 0x1f, 0x0a, 0x0c, 0x56, 0x66, 0x70, 0x44, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x55, 0x54, 0x10, 0x00, + 0x12, 0x06, 0x0a, 0x02, 0x49, 0x4e, 0x10, 0x01, 0x42, 0x27, 0x5a, 0x25, 0x67, 0x69, 0x74, 0x68, + 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, + 0x2f, 0x72, 0x65, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x75, 0x74, 0x69, 0x6c, + 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( - file_pkg_utils_metadata_linux_proto_rawDescOnce sync.Once - file_pkg_utils_metadata_linux_proto_rawDescData = file_pkg_utils_metadata_linux_proto_rawDesc + file_metadata_linux_proto_rawDescOnce sync.Once + file_metadata_linux_proto_rawDescData = file_metadata_linux_proto_rawDesc ) -func file_pkg_utils_metadata_linux_proto_rawDescGZIP() []byte { - file_pkg_utils_metadata_linux_proto_rawDescOnce.Do(func() { - file_pkg_utils_metadata_linux_proto_rawDescData = protoimpl.X.CompressGZIP(file_pkg_utils_metadata_linux_proto_rawDescData) +func file_metadata_linux_proto_rawDescGZIP() []byte { + file_metadata_linux_proto_rawDescOnce.Do(func() { + file_metadata_linux_proto_rawDescData = protoimpl.X.CompressGZIP(file_metadata_linux_proto_rawDescData) }) - return file_pkg_utils_metadata_linux_proto_rawDescData -} - -var file_pkg_utils_metadata_linux_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_pkg_utils_metadata_linux_proto_msgTypes = make([]protoimpl.MessageInfo, 2) -var file_pkg_utils_metadata_linux_proto_goTypes = []any{ - (DNSType)(0), // 0: utils.DNSType - (DropReason)(0), // 1: utils.DropReason - (*RetinaMetadata)(nil), // 2: utils.RetinaMetadata - nil, // 3: utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry -} -var file_pkg_utils_metadata_linux_proto_depIdxs = []int32{ - 0, // 0: utils.RetinaMetadata.dns_type:type_name -> utils.DNSType - 1, // 1: utils.RetinaMetadata.drop_reason:type_name -> utils.DropReason - 3, // 2: utils.RetinaMetadata.previously_observed_tcp_flags:type_name -> utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry - 3, // [3:3] is the sub-list for method output_type - 3, // [3:3] is the sub-list for method input_type - 3, // [3:3] is the sub-list for extension type_name - 3, // [3:3] is the sub-list for extension extendee - 0, // [0:3] is the sub-list for field type_name -} - -func init() { file_pkg_utils_metadata_linux_proto_init() } -func file_pkg_utils_metadata_linux_proto_init() { - if File_pkg_utils_metadata_linux_proto != nil { + return file_metadata_linux_proto_rawDescData +} + +var file_metadata_linux_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_metadata_linux_proto_msgTypes = make([]protoimpl.MessageInfo, 10) +var file_metadata_linux_proto_goTypes = []interface{}{ + (DNSType)(0), // 0: utils.DNSType + (DropReason)(0), // 1: utils.DropReason + (VfpDirection)(0), // 2: utils.VfpDirection + (*RetinaMetadata)(nil), // 3: utils.RetinaMetadata + (*EndpointStats)(nil), // 4: utils.EndpointStats + (*VfpTcpConnectionStats)(nil), // 5: utils.VfpTcpConnectionStats + (*VfpTcpPacketStats)(nil), // 6: utils.VfpTcpPacketStats + (*VfpPacketDropStats)(nil), // 7: utils.VfpPacketDropStats + (*VfpTcpStats)(nil), // 8: utils.VfpTcpStats + (*VfpDirectedPortCounters)(nil), // 9: utils.VfpDirectedPortCounters + (*VfpPortStatsData)(nil), // 10: utils.VfpPortStatsData + (*HNSStatsMetadata)(nil), // 11: utils.HNSStatsMetadata + nil, // 12: utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry +} +var file_metadata_linux_proto_depIdxs = []int32{ + 0, // 0: utils.RetinaMetadata.dns_type:type_name -> utils.DNSType + 1, // 1: utils.RetinaMetadata.drop_reason:type_name -> utils.DropReason + 12, // 2: utils.RetinaMetadata.previously_observed_tcp_flags:type_name -> utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry + 5, // 3: utils.VfpTcpStats.ConnectionCounters:type_name -> utils.VfpTcpConnectionStats + 6, // 4: utils.VfpTcpStats.PacketCounters:type_name -> utils.VfpTcpPacketStats + 2, // 5: utils.VfpDirectedPortCounters.direction:type_name -> utils.VfpDirection + 8, // 6: utils.VfpDirectedPortCounters.TcpCounters:type_name -> utils.VfpTcpStats + 7, // 7: utils.VfpDirectedPortCounters.DropCounters:type_name -> utils.VfpPacketDropStats + 9, // 8: utils.VfpPortStatsData.In:type_name -> utils.VfpDirectedPortCounters + 9, // 9: utils.VfpPortStatsData.Out:type_name -> utils.VfpDirectedPortCounters + 4, // 10: utils.HNSStatsMetadata.EndpointStats:type_name -> utils.EndpointStats + 10, // 11: utils.HNSStatsMetadata.VfpPortStatsData:type_name -> utils.VfpPortStatsData + 12, // [12:12] is the sub-list for method output_type + 12, // [12:12] is the sub-list for method input_type + 12, // [12:12] is the sub-list for extension type_name + 12, // [12:12] is the sub-list for extension extendee + 0, // [0:12] is the sub-list for field type_name +} + +func init() { file_metadata_linux_proto_init() } +func file_metadata_linux_proto_init() { + if File_metadata_linux_proto != nil { return } if !protoimpl.UnsafeEnabled { - file_pkg_utils_metadata_linux_proto_msgTypes[0].Exporter = func(v any, i int) any { + file_metadata_linux_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*RetinaMetadata); i { case 0: return &v.state @@ -344,24 +1051,120 @@ func file_pkg_utils_metadata_linux_proto_init() { return nil } } + file_metadata_linux_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EndpointStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_linux_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpTcpConnectionStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_linux_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpTcpPacketStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_linux_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpPacketDropStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_linux_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpTcpStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_linux_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpDirectedPortCounters); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_linux_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpPortStatsData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_linux_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HNSStatsMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_pkg_utils_metadata_linux_proto_rawDesc, - NumEnums: 2, - NumMessages: 2, + RawDescriptor: file_metadata_linux_proto_rawDesc, + NumEnums: 3, + NumMessages: 10, NumExtensions: 0, NumServices: 0, }, - GoTypes: file_pkg_utils_metadata_linux_proto_goTypes, - DependencyIndexes: file_pkg_utils_metadata_linux_proto_depIdxs, - EnumInfos: file_pkg_utils_metadata_linux_proto_enumTypes, - MessageInfos: file_pkg_utils_metadata_linux_proto_msgTypes, + GoTypes: file_metadata_linux_proto_goTypes, + DependencyIndexes: file_metadata_linux_proto_depIdxs, + EnumInfos: file_metadata_linux_proto_enumTypes, + MessageInfos: file_metadata_linux_proto_msgTypes, }.Build() - File_pkg_utils_metadata_linux_proto = out.File - file_pkg_utils_metadata_linux_proto_rawDesc = nil - file_pkg_utils_metadata_linux_proto_goTypes = nil - file_pkg_utils_metadata_linux_proto_depIdxs = nil + File_metadata_linux_proto = out.File + file_metadata_linux_proto_rawDesc = nil + file_metadata_linux_proto_goTypes = nil + file_metadata_linux_proto_depIdxs = nil } diff --git a/pkg/utils/metadata_linux.proto b/pkg/utils/metadata_linux.proto index 9e939bccd1..e5dd4d6a1b 100644 --- a/pkg/utils/metadata_linux.proto +++ b/pkg/utils/metadata_linux.proto @@ -38,3 +38,62 @@ enum DropReason { CONNTRACK_ADD_DROP = 5; UNKNOWN_DROP = 6; } + +// HNS stats for standalone +enum VfpDirection { + OUT = 0; + IN = 1; +} + +message EndpointStats { + uint64 BytesReceived = 1; + uint64 BytesSent = 2; + uint64 DroppedPacketsIncoming = 3; + uint64 DroppedPacketsOutgoing = 4; + string EndpointID = 5; + string InstanceID = 6; + uint64 PacketsReceived = 7; + uint64 PacketsSent = 8; +} + +message VfpTcpConnectionStats { + uint64 VerifiedCount = 1; + uint64 TimedOutCount = 2; + uint64 ResetCount = 3; + uint64 ResetSynCount = 4; + uint64 ClosedFinCount = 5; + uint64 TcpHalfOpenTimeoutsCount = 6; + uint64 TimeWaitExpiredCount = 7; +} + +message VfpTcpPacketStats { + uint64 SynPacketCount = 1; + uint64 SynAckPacketCount = 2; + uint64 FinPacketCount = 3; + uint64 RstPacketCount = 4; +} + +message VfpPacketDropStats { + uint64 AclDropPacketCount = 1; +} + +message VfpTcpStats { + VfpTcpConnectionStats ConnectionCounters = 1; + VfpTcpPacketStats PacketCounters = 2; +} + +message VfpDirectedPortCounters { + VfpDirection direction = 1; + VfpTcpStats TcpCounters = 2; + VfpPacketDropStats DropCounters = 3; +} + +message VfpPortStatsData { + VfpDirectedPortCounters In = 1; + VfpDirectedPortCounters Out = 2; +} + +message HNSStatsMetadata { + EndpointStats EndpointStats = 1; + VfpPortStatsData VfpPortStatsData = 2; +} diff --git a/pkg/utils/metadata_windows.pb.go b/pkg/utils/metadata_windows.pb.go index c6b45e6dfb..dc3c67607e 100644 --- a/pkg/utils/metadata_windows.pb.go +++ b/pkg/utils/metadata_windows.pb.go @@ -1,8 +1,8 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.34.2 -// protoc v4.24.2 -// source: pkg/utils/metadata_windows.proto +// protoc-gen-go v1.25.0-devel +// protoc v3.14.0 +// source: metadata_windows.proto package utils @@ -20,6 +20,53 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +// HNS stats for standalone +type VfpDirection int32 + +const ( + VfpDirection_OUT VfpDirection = 0 + VfpDirection_IN VfpDirection = 1 +) + +// Enum value maps for VfpDirection. +var ( + VfpDirection_name = map[int32]string{ + 0: "OUT", + 1: "IN", + } + VfpDirection_value = map[string]int32{ + "OUT": 0, + "IN": 1, + } +) + +func (x VfpDirection) Enum() *VfpDirection { + p := new(VfpDirection) + *p = x + return p +} + +func (x VfpDirection) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VfpDirection) Descriptor() protoreflect.EnumDescriptor { + return file_metadata_windows_proto_enumTypes[0].Descriptor() +} + +func (VfpDirection) Type() protoreflect.EnumType { + return &file_metadata_windows_proto_enumTypes[0] +} + +func (x VfpDirection) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use VfpDirection.Descriptor instead. +func (VfpDirection) EnumDescriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{0} +} + type DNSType int32 const ( @@ -53,11 +100,11 @@ func (x DNSType) String() string { } func (DNSType) Descriptor() protoreflect.EnumDescriptor { - return file_pkg_utils_metadata_windows_proto_enumTypes[0].Descriptor() + return file_metadata_windows_proto_enumTypes[1].Descriptor() } func (DNSType) Type() protoreflect.EnumType { - return &file_pkg_utils_metadata_windows_proto_enumTypes[0] + return &file_metadata_windows_proto_enumTypes[1] } func (x DNSType) Number() protoreflect.EnumNumber { @@ -66,7 +113,7 @@ func (x DNSType) Number() protoreflect.EnumNumber { // Deprecated: Use DNSType.Descriptor instead. func (DNSType) EnumDescriptor() ([]byte, []int) { - return file_pkg_utils_metadata_windows_proto_rawDescGZIP(), []int{0} + return file_metadata_windows_proto_rawDescGZIP(), []int{1} } type DropReason int32 @@ -111,7 +158,9 @@ const ( DropReason_Drop_FilteredIsolationUntagged DropReason = 36 DropReason_Drop_InvalidPDQueue DropReason = 37 DropReason_Drop_LowPower DropReason = 38 + // // General errors + // DropReason_Drop_Pause DropReason = 201 DropReason_Drop_Reset DropReason = 202 DropReason_Drop_SendAborted DropReason = 203 @@ -139,12 +188,16 @@ const ( DropReason_Drop_UnallowedEtherType DropReason = 226 DropReason_Drop_VportDown DropReason = 227 DropReason_Drop_SteeringMismatch DropReason = 228 + // // NetVsc errors + // DropReason_Drop_MicroportError DropReason = 401 DropReason_Drop_VfNotReady DropReason = 402 DropReason_Drop_MicroportNotReady DropReason = 403 DropReason_Drop_VMBusError DropReason = 404 + // // Tcpip FL errors + // DropReason_Drop_FL_LoopbackPacket DropReason = 601 DropReason_Drop_FL_InvalidSnapHeader DropReason = 602 DropReason_Drop_FL_InvalidEthernetType DropReason = 603 @@ -160,7 +213,9 @@ const ( DropReason_Drop_FL_NoClientInterface DropReason = 613 DropReason_Drop_FL_TooManyNetBuffers DropReason = 614 DropReason_Drop_FL_FlsNpiClientDrop DropReason = 615 + // // VFP errors + // DropReason_Drop_ArpGuard DropReason = 701 DropReason_Drop_ArpLimiter DropReason = 702 DropReason_Drop_DhcpLimiter DropReason = 703 @@ -180,7 +235,9 @@ const ( DropReason_Drop_NDPGuard DropReason = 717 DropReason_Drop_PortBlocked DropReason = 718 DropReason_Drop_NicSuspended DropReason = 719 + // // Tcpip NL errors + // DropReason_Drop_NL_BadSourceAddress DropReason = 901 DropReason_Drop_NL_NotLocallyDestined DropReason = 902 DropReason_Drop_NL_ProtocolUnreachable DropReason = 903 @@ -283,7 +340,9 @@ const ( DropReason_Drop_NL_SourceViolation DropReason = 1000 DropReason_Drop_NL_IcmpJumbogram DropReason = 1001 DropReason_Drop_NL_SwUsoFailure DropReason = 1002 + // // INET discard reasons + // DropReason_Drop_INET_SourceUnspecified DropReason = 1200 DropReason_Drop_INET_DestinationMulticast DropReason = 1201 DropReason_Drop_INET_HeaderInvalid DropReason = 1202 @@ -317,7 +376,9 @@ const ( DropReason_Drop_INET_SynAttack DropReason = 1230 DropReason_Drop_INET_AcceptInspection DropReason = 1231 DropReason_Drop_INET_AcceptRedirection DropReason = 1232 + // // Slbmux Error + // DropReason_Drop_SlbMux_ParsingFailure DropReason = 1301 DropReason_Drop_SlbMux_FirstFragmentMiss DropReason = 1302 DropReason_Drop_SlbMux_ICMPErrorPayloadValidationFailure DropReason = 1303 @@ -345,7 +406,9 @@ const ( DropReason_Drop_SlbMux_InvalidDiagPacketEncapType DropReason = 1325 DropReason_Drop_SlbMux_DiagPacketIsRedirect DropReason = 1326 DropReason_Drop_SlbMux_UnableToHandleRedirect DropReason = 1327 + // // Ipsec Errors + // DropReason_Drop_Ipsec_BadSpi DropReason = 1401 DropReason_Drop_Ipsec_SALifetimeExpired DropReason = 1402 DropReason_Drop_Ipsec_WrongSA DropReason = 1403 @@ -364,7 +427,9 @@ const ( DropReason_Drop_Ipsec_Dosp_MaxPerIpRateLimitQueues DropReason = 1416 DropReason_Drop_Ipsec_NoMemory DropReason = 1417 DropReason_Drop_Ipsec_Unsuccessful DropReason = 1418 + // // NetCx Drop Reasons + // DropReason_Drop_NetCx_NetPacketLayoutParseFailure DropReason = 1501 DropReason_Drop_NetCx_SoftwareChecksumFailure DropReason = 1502 DropReason_Drop_NetCx_NicQueueStop DropReason = 1503 @@ -372,10 +437,14 @@ const ( DropReason_Drop_NetCx_LSOFailure DropReason = 1505 DropReason_Drop_NetCx_USOFailure DropReason = 1506 DropReason_Drop_NetCx_BufferBounceFailureAndPacketIgnore DropReason = 1507 + // // Http errors 3000 - 4000. // These must be in sync with cmd\resource.h + // DropReason_Drop_Http_Begin DropReason = 3000 + // // UlErrors + // DropReason_Drop_Http_UlError_Begin DropReason = 3001 DropReason_Drop_Http_UlError DropReason = 3002 DropReason_Drop_Http_UlErrorVerb DropReason = 3003 @@ -470,9 +539,13 @@ const ( DropReason_Drop_Http_UxDuoFaultContentLengthDisallowed DropReason = 3461 DropReason_Drop_Http_UxDuoFaultTrailerDisallowed DropReason = 3462 DropReason_Drop_Http_UxDuoFaultEnd DropReason = 3463 - // WSK layer drops + // + // WSK layer drops + // DropReason_Drop_Http_ReceiveSuppressed DropReason = 3600 - // Http/SSL layer drops + // + // Http/SSL layer drops + // DropReason_Drop_Http_Generic DropReason = 3800 DropReason_Drop_Http_InvalidParameter DropReason = 3801 DropReason_Drop_Http_InsufficientResources DropReason = 3802 @@ -1316,11 +1389,11 @@ func (x DropReason) String() string { } func (DropReason) Descriptor() protoreflect.EnumDescriptor { - return file_pkg_utils_metadata_windows_proto_enumTypes[1].Descriptor() + return file_metadata_windows_proto_enumTypes[2].Descriptor() } func (DropReason) Type() protoreflect.EnumType { - return &file_pkg_utils_metadata_windows_proto_enumTypes[1] + return &file_metadata_windows_proto_enumTypes[2] } func (x DropReason) Number() protoreflect.EnumNumber { @@ -1329,7 +1402,7 @@ func (x DropReason) Number() protoreflect.EnumNumber { // Deprecated: Use DropReason.Descriptor instead. func (DropReason) EnumDescriptor() ([]byte, []int) { - return file_pkg_utils_metadata_windows_proto_rawDescGZIP(), []int{1} + return file_metadata_windows_proto_rawDescGZIP(), []int{2} } type RetinaMetadata struct { @@ -1354,7 +1427,7 @@ type RetinaMetadata struct { func (x *RetinaMetadata) Reset() { *x = RetinaMetadata{} if protoimpl.UnsafeEnabled { - mi := &file_pkg_utils_metadata_windows_proto_msgTypes[0] + mi := &file_metadata_windows_proto_msgTypes[0] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1367,7 +1440,7 @@ func (x *RetinaMetadata) String() string { func (*RetinaMetadata) ProtoMessage() {} func (x *RetinaMetadata) ProtoReflect() protoreflect.Message { - mi := &file_pkg_utils_metadata_windows_proto_msgTypes[0] + mi := &file_metadata_windows_proto_msgTypes[0] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1380,7 +1453,7 @@ func (x *RetinaMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use RetinaMetadata.ProtoReflect.Descriptor instead. func (*RetinaMetadata) Descriptor() ([]byte, []int) { - return file_pkg_utils_metadata_windows_proto_rawDescGZIP(), []int{0} + return file_metadata_windows_proto_rawDescGZIP(), []int{0} } func (x *RetinaMetadata) GetBytes() uint32 { @@ -1439,938 +1512,1694 @@ func (x *RetinaMetadata) GetPreviouslyObservedTcpFlags() map[string]uint32 { return nil } -var File_pkg_utils_metadata_windows_proto protoreflect.FileDescriptor - -var file_pkg_utils_metadata_windows_proto_rawDesc = []byte{ - 0x0a, 0x20, 0x70, 0x6b, 0x67, 0x2f, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2f, 0x6d, 0x65, 0x74, 0x61, - 0x64, 0x61, 0x74, 0x61, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x12, 0x05, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x22, 0x86, 0x04, 0x0a, 0x0e, 0x52, 0x65, - 0x74, 0x69, 0x6e, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, - 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x62, 0x79, 0x74, - 0x65, 0x73, 0x12, 0x29, 0x0a, 0x08, 0x64, 0x6e, 0x73, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0e, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x44, 0x4e, 0x53, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x64, 0x6e, 0x73, 0x54, 0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, - 0x0d, 0x6e, 0x75, 0x6d, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x73, 0x12, 0x15, 0x0a, 0x06, 0x74, 0x63, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x04, 0x52, 0x05, 0x74, 0x63, 0x70, 0x49, 0x64, 0x12, 0x32, 0x0a, 0x0b, 0x64, 0x72, 0x6f, - 0x70, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, - 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, - 0x6e, 0x52, 0x0a, 0x64, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, - 0x1b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x0d, 0x52, 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, - 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x12, 0x3a, 0x0a, - 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, - 0x52, 0x17, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, - 0x72, 0x76, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, 0x78, 0x0a, 0x1d, 0x70, 0x72, 0x65, - 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, - 0x5f, 0x74, 0x63, 0x70, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, - 0x32, 0x35, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x52, 0x65, 0x74, 0x69, 0x6e, 0x61, 0x4d, - 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, - 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, 0x70, 0x46, 0x6c, 0x61, - 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x1a, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, - 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, 0x70, 0x46, 0x6c, - 0x61, 0x67, 0x73, 0x1a, 0x4d, 0x0a, 0x1f, 0x50, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, - 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, - 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, - 0x38, 0x01, 0x2a, 0x2f, 0x0a, 0x07, 0x44, 0x4e, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, - 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x51, 0x55, - 0x45, 0x52, 0x59, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x52, 0x45, 0x53, 0x50, 0x4f, 0x4e, 0x53, - 0x45, 0x10, 0x02, 0x2a, 0xe0, 0x69, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, - 0x77, 0x6e, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, - 0x61, 0x6c, 0x69, 0x64, 0x44, 0x61, 0x74, 0x61, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, - 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x73, 0x10, 0x03, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, 0x04, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x10, 0x05, - 0x12, 0x14, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x6f, 0x74, 0x41, 0x63, 0x63, 0x65, - 0x70, 0x74, 0x65, 0x64, 0x10, 0x06, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, - 0x75, 0x73, 0x79, 0x10, 0x07, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x69, - 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x56, 0x4c, 0x41, 0x4e, 0x10, 0x09, 0x12, - 0x19, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, - 0x69, 0x7a, 0x65, 0x64, 0x56, 0x4c, 0x41, 0x4e, 0x10, 0x0a, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x4d, - 0x41, 0x43, 0x10, 0x0b, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x61, 0x69, - 0x6c, 0x65, 0x64, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, - 0x79, 0x10, 0x0c, 0x12, 0x1b, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x61, 0x69, 0x6c, - 0x65, 0x64, 0x50, 0x76, 0x6c, 0x61, 0x6e, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x10, 0x0d, - 0x12, 0x0c, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x51, 0x6f, 0x73, 0x10, 0x0e, 0x12, 0x0e, - 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x10, 0x0f, 0x12, 0x14, - 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4d, 0x61, 0x63, 0x53, 0x70, 0x6f, 0x6f, 0x66, 0x69, - 0x6e, 0x67, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x68, 0x63, - 0x70, 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0x11, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0x12, 0x12, 0x17, - 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x52, 0x65, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x64, 0x10, 0x13, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x56, 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x53, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x49, 0x64, 0x10, - 0x14, 0x12, 0x21, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, - 0x65, 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x73, 0x73, 0x69, - 0x6e, 0x67, 0x10, 0x15, 0x12, 0x16, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, - 0x61, 0x6c, 0x69, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x10, 0x16, 0x12, 0x14, 0x0a, 0x10, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4d, 0x54, 0x55, 0x4d, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x63, 0x68, - 0x10, 0x17, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x61, 0x74, 0x69, 0x76, - 0x65, 0x46, 0x77, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x10, 0x18, 0x12, 0x1a, 0x0a, 0x16, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x56, 0x6c, 0x61, 0x6e, - 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x10, 0x19, 0x12, 0x17, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x44, 0x65, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x10, - 0x1a, 0x12, 0x19, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, - 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x61, 0x63, 0x10, 0x1b, 0x12, 0x1f, 0x0a, 0x1b, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x46, 0x69, 0x72, 0x73, - 0x74, 0x4e, 0x42, 0x54, 0x6f, 0x6f, 0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x10, 0x1c, 0x12, 0x0c, 0x0a, - 0x08, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x57, 0x6e, 0x76, 0x10, 0x1d, 0x12, 0x13, 0x0a, 0x0f, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x74, 0x6f, 0x72, 0x6d, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0x1e, - 0x12, 0x15, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, - 0x64, 0x49, 0x63, 0x6d, 0x70, 0x10, 0x1f, 0x12, 0x24, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x10, 0x20, 0x12, 0x14, 0x0a, - 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x69, 0x63, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, - 0x64, 0x10, 0x21, 0x12, 0x1b, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x61, 0x69, 0x6c, - 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x10, 0x22, - 0x12, 0x1f, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x44, - 0x61, 0x74, 0x61, 0x46, 0x6c, 0x6f, 0x77, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x10, - 0x23, 0x12, 0x22, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, - 0x65, 0x64, 0x49, 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x74, 0x61, 0x67, - 0x67, 0x65, 0x64, 0x10, 0x24, 0x12, 0x17, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, - 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x44, 0x51, 0x75, 0x65, 0x75, 0x65, 0x10, 0x25, 0x12, 0x11, - 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4c, 0x6f, 0x77, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x10, - 0x26, 0x12, 0x0f, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x50, 0x61, 0x75, 0x73, 0x65, 0x10, - 0xc9, 0x01, 0x12, 0x0f, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x52, 0x65, 0x73, 0x65, 0x74, - 0x10, 0xca, 0x01, 0x12, 0x15, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x65, 0x6e, 0x64, - 0x41, 0x62, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x10, 0xcb, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x4e, 0x6f, 0x74, 0x42, 0x6f, - 0x75, 0x6e, 0x64, 0x10, 0xcc, 0x01, 0x12, 0x11, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, - 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xcd, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, - 0xce, 0x01, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x6f, 0x73, 0x74, 0x4f, - 0x75, 0x74, 0x4f, 0x66, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10, 0xcf, 0x01, 0x12, 0x16, 0x0a, - 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x54, 0x6f, 0x6f, 0x4c, 0x6f, - 0x6e, 0x67, 0x10, 0xd0, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x72, - 0x61, 0x6d, 0x65, 0x54, 0x6f, 0x6f, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x10, 0xd1, 0x01, 0x12, 0x1a, - 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4c, 0x65, 0x6e, 0x67, - 0x74, 0x68, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xd2, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x43, 0x72, 0x63, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xd3, 0x01, 0x12, 0x1a, - 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x61, 0x64, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x43, - 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x10, 0xd4, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x46, 0x63, 0x73, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xd5, 0x01, 0x12, 0x15, - 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x45, 0x72, 0x72, - 0x6f, 0x72, 0x10, 0xd6, 0x01, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x65, - 0x61, 0x64, 0x51, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x10, 0xd7, 0x01, 0x12, 0x18, 0x0a, - 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x44, 0x69, 0x73, - 0x63, 0x61, 0x72, 0x64, 0x10, 0xd8, 0x01, 0x12, 0x11, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x52, 0x78, 0x51, 0x46, 0x75, 0x6c, 0x6c, 0x10, 0xd9, 0x01, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x50, 0x68, 0x79, 0x73, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, - 0x72, 0x10, 0xda, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x6d, 0x61, - 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xdb, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xdc, - 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xdd, 0x01, 0x12, 0x16, 0x0a, - 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x61, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, - 0x72, 0x65, 0x10, 0xde, 0x01, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x43, 0x6f, - 0x61, 0x6c, 0x65, 0x73, 0x63, 0x69, 0x6e, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xdf, 0x01, - 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, 0x6c, 0x61, 0x6e, 0x53, 0x70, 0x6f, - 0x6f, 0x66, 0x69, 0x6e, 0x67, 0x10, 0xe1, 0x01, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x55, 0x6e, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x45, 0x74, 0x68, 0x65, 0x72, 0x54, - 0x79, 0x70, 0x65, 0x10, 0xe2, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, - 0x70, 0x6f, 0x72, 0x74, 0x44, 0x6f, 0x77, 0x6e, 0x10, 0xe3, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x69, 0x73, 0x6d, - 0x61, 0x74, 0x63, 0x68, 0x10, 0xe4, 0x01, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0x91, - 0x03, 0x12, 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, 0x66, 0x4e, 0x6f, 0x74, 0x52, - 0x65, 0x61, 0x64, 0x79, 0x10, 0x92, 0x03, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x4e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, - 0x79, 0x10, 0x93, 0x03, 0x12, 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, 0x4d, 0x42, - 0x75, 0x73, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0x94, 0x03, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x4c, 0x6f, 0x6f, 0x70, 0x62, 0x61, 0x63, 0x6b, 0x50, 0x61, - 0x63, 0x6b, 0x65, 0x74, 0x10, 0xd9, 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x53, 0x6e, 0x61, 0x70, 0x48, 0x65, - 0x61, 0x64, 0x65, 0x72, 0x10, 0xda, 0x04, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x45, 0x74, 0x68, 0x65, 0x72, 0x6e, - 0x65, 0x74, 0x54, 0x79, 0x70, 0x65, 0x10, 0xdb, 0x04, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, - 0x65, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xdc, 0x04, 0x12, 0x20, 0x0a, 0x1b, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4e, 0x6f, 0x74, - 0x43, 0x6f, 0x6e, 0x74, 0x69, 0x67, 0x75, 0x6f, 0x75, 0x73, 0x10, 0xdd, 0x04, 0x12, 0x23, 0x0a, - 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, - 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x10, - 0xde, 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, - 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, - 0xdf, 0x04, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x50, 0x72, - 0x6f, 0x76, 0x69, 0x64, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, 0xe0, - 0x04, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, - 0x61, 0x6c, 0x69, 0x64, 0x4c, 0x73, 0x6f, 0x49, 0x6e, 0x66, 0x6f, 0x10, 0xe1, 0x04, 0x12, 0x1b, - 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, - 0x64, 0x55, 0x73, 0x6f, 0x49, 0x6e, 0x66, 0x6f, 0x10, 0xe2, 0x04, 0x12, 0x1a, 0x0a, 0x15, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4d, 0x65, - 0x64, 0x69, 0x75, 0x6d, 0x10, 0xe3, 0x04, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x41, 0x72, 0x70, 0x48, 0x65, 0x61, - 0x64, 0x65, 0x72, 0x10, 0xe4, 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, - 0x4c, 0x5f, 0x4e, 0x6f, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, - 0x61, 0x63, 0x65, 0x10, 0xe5, 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, - 0x4c, 0x5f, 0x54, 0x6f, 0x6f, 0x4d, 0x61, 0x6e, 0x79, 0x4e, 0x65, 0x74, 0x42, 0x75, 0x66, 0x66, - 0x65, 0x72, 0x73, 0x10, 0xe6, 0x04, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, - 0x4c, 0x5f, 0x46, 0x6c, 0x73, 0x4e, 0x70, 0x69, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x44, 0x72, - 0x6f, 0x70, 0x10, 0xe7, 0x04, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x41, 0x72, - 0x70, 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0xbd, 0x05, 0x12, 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x41, 0x72, 0x70, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x10, 0xbe, 0x05, 0x12, - 0x15, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x68, 0x63, 0x70, 0x4c, 0x69, 0x6d, 0x69, - 0x74, 0x65, 0x72, 0x10, 0xbf, 0x05, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, - 0x6c, 0x6f, 0x63, 0x6b, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x10, 0xc0, 0x05, - 0x12, 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x6f, - 0x6e, 0x49, 0x70, 0x10, 0xc1, 0x05, 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x41, - 0x72, 0x70, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x10, 0xc2, 0x05, 0x12, 0x13, 0x0a, 0x0e, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x76, 0x34, 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0xc3, 0x05, - 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x76, 0x36, 0x47, 0x75, 0x61, - 0x72, 0x64, 0x10, 0xc4, 0x05, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4d, 0x61, - 0x63, 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0xc5, 0x05, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x4e, 0x6f, 0x44, 0x65, 0x73, - 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x10, 0xc6, 0x05, 0x12, 0x1e, 0x0a, 0x19, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x69, 0x63, 0x61, 0x73, 0x74, 0x4e, 0x6f, 0x44, 0x65, - 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xc7, 0x05, 0x12, 0x1d, 0x0a, 0x18, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x69, 0x63, 0x61, 0x73, 0x74, 0x50, 0x6f, 0x72, 0x74, - 0x4e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, 0xc8, 0x05, 0x12, 0x1e, 0x0a, 0x19, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x43, 0x61, 0x6c, 0x6c, 0x62, 0x61, - 0x63, 0x6b, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xc9, 0x05, 0x12, 0x17, 0x0a, 0x12, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x76, 0x36, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x65, - 0x72, 0x10, 0xca, 0x05, 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x74, - 0x65, 0x72, 0x63, 0x65, 0x70, 0x74, 0x10, 0xcb, 0x05, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65, 0x70, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, - 0x10, 0xcc, 0x05, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x44, 0x50, 0x47, - 0x75, 0x61, 0x72, 0x64, 0x10, 0xcd, 0x05, 0x12, 0x15, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x50, 0x6f, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x10, 0xce, 0x05, 0x12, 0x16, - 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x69, 0x63, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, - 0x64, 0x65, 0x64, 0x10, 0xcf, 0x05, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x4c, 0x5f, 0x42, 0x61, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, - 0x73, 0x73, 0x10, 0x85, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, - 0x5f, 0x4e, 0x6f, 0x74, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x44, 0x65, 0x73, 0x74, 0x69, - 0x6e, 0x65, 0x64, 0x10, 0x86, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x4c, 0x5f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x55, 0x6e, 0x72, 0x65, 0x61, 0x63, - 0x68, 0x61, 0x62, 0x6c, 0x65, 0x10, 0x87, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x4e, 0x4c, 0x5f, 0x50, 0x6f, 0x72, 0x74, 0x55, 0x6e, 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, - 0x62, 0x6c, 0x65, 0x10, 0x88, 0x07, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x4c, 0x5f, 0x42, 0x61, 0x64, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0x89, 0x07, 0x12, 0x1c, - 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4d, 0x61, 0x6c, 0x66, 0x6f, 0x72, - 0x6d, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0x8a, 0x07, 0x12, 0x14, 0x0a, 0x0f, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x10, - 0x8b, 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x42, 0x65, - 0x79, 0x6f, 0x6e, 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x10, 0x8c, 0x07, 0x12, 0x1b, 0x0a, 0x16, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x44, 0x72, 0x6f, 0x70, 0x10, 0x8d, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x54, 0x6f, 0x6f, 0x4d, 0x61, 0x6e, 0x79, 0x44, 0x65, 0x63, 0x61, - 0x70, 0x73, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x10, 0x8e, 0x07, 0x12, 0x27, 0x0a, - 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, - 0x74, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x50, 0x72, 0x6f, 0x68, 0x69, 0x62, 0x69, - 0x74, 0x65, 0x64, 0x10, 0x8f, 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x4c, 0x5f, 0x42, 0x61, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x10, 0x90, 0x07, - 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x65, 0x63, 0x65, - 0x69, 0x76, 0x65, 0x50, 0x61, 0x74, 0x68, 0x4d, 0x61, 0x78, 0x10, 0x91, 0x07, 0x12, 0x1d, 0x0a, - 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x48, 0x6f, 0x70, 0x4c, 0x69, 0x6d, 0x69, - 0x74, 0x45, 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x92, 0x07, 0x12, 0x1f, 0x0a, 0x1a, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x55, - 0x6e, 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x6c, 0x65, 0x10, 0x93, 0x07, 0x12, 0x16, 0x0a, - 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x73, 0x63, 0x50, 0x61, 0x63, 0x6b, - 0x65, 0x74, 0x10, 0x94, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, - 0x5f, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x50, 0x61, 0x74, 0x68, 0x4d, 0x61, 0x78, 0x10, - 0x95, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, - 0x62, 0x69, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x68, 0x61, 0x6e, 0x64, 0x6c, - 0x65, 0x64, 0x10, 0x96, 0x07, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, - 0x5f, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x62, 0x73, 0x6f, 0x72, - 0x62, 0x10, 0x97, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x44, 0x6f, 0x6e, 0x74, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4d, 0x74, 0x75, 0x45, - 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x98, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x4c, 0x65, 0x6e, 0x67, - 0x74, 0x68, 0x45, 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x99, 0x07, 0x12, 0x25, 0x0a, - 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, - 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, - 0x74, 0x10, 0x9a, 0x07, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, - 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x9b, 0x07, 0x12, 0x19, 0x0a, 0x14, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x46, 0x61, 0x69, 0x6c, - 0x75, 0x72, 0x65, 0x10, 0x9c, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x4c, 0x5f, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x73, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x9d, 0x07, 0x12, 0x1d, 0x0a, 0x18, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x43, 0x6c, - 0x69, 0x65, 0x6e, 0x74, 0x44, 0x72, 0x6f, 0x70, 0x10, 0x9e, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, - 0x65, 0x64, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x10, 0x9f, 0x07, 0x12, 0x1b, 0x0a, 0x16, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x46, - 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa0, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x6e, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x79, 0x44, 0x61, - 0x74, 0x61, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa1, 0x07, 0x12, 0x1b, 0x0a, 0x16, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x61, 0x77, 0x44, 0x61, 0x74, 0x61, 0x46, - 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa2, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa3, 0x07, 0x12, 0x2a, 0x0a, 0x25, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4d, 0x6f, 0x64, - 0x69, 0x66, 0x69, 0x65, 0x64, 0x42, 0x75, 0x74, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x72, 0x77, 0x61, - 0x72, 0x64, 0x65, 0x64, 0x10, 0xa4, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x4e, 0x65, 0x78, 0x74, 0x48, - 0x6f, 0x70, 0x10, 0xa5, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, - 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x74, - 0x6d, 0x65, 0x6e, 0x74, 0x10, 0xa6, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x49, 0x6e, 0x74, 0x65, 0x72, - 0x66, 0x61, 0x63, 0x65, 0x10, 0xa7, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x53, 0x75, 0x62, 0x49, 0x6e, - 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x10, 0xa8, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x66, 0x61, 0x63, 0x65, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x10, 0xa9, 0x07, - 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, - 0x70, 0x69, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, - 0x69, 0x6c, 0x65, 0x64, 0x10, 0xaa, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x45, 0x74, 0x68, 0x65, 0x72, - 0x6e, 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xab, 0x07, 0x12, 0x25, 0x0a, 0x20, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x55, 0x6e, - 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x10, 0xac, 0x07, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, - 0x70, 0x73, 0x6e, 0x70, 0x69, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, - 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x10, 0xad, 0x07, - 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, - 0x70, 0x69, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4c, 0x73, 0x6f, 0x49, 0x6e, 0x66, 0x6f, - 0x10, 0xae, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, - 0x70, 0x73, 0x6e, 0x70, 0x69, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x55, 0x73, 0x6f, 0x49, - 0x6e, 0x66, 0x6f, 0x10, 0xaf, 0x07, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x4c, 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, - 0xb0, 0x07, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, - 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x10, 0xb1, 0x07, 0x12, 0x16, 0x0a, 0x11, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x42, 0x61, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, - 0x10, 0xb2, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4c, - 0x6f, 0x6f, 0x70, 0x62, 0x61, 0x63, 0x6b, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, - 0x64, 0x10, 0xb3, 0x07, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x10, 0xb4, 0x07, 0x12, - 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x51, 0x75, 0x65, 0x75, 0x65, - 0x46, 0x75, 0x6c, 0x6c, 0x10, 0xb5, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4e, 0x4c, 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x44, 0x69, 0x73, 0x61, - 0x62, 0x6c, 0x65, 0x64, 0x10, 0xb6, 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x10, 0xb7, - 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, - 0x70, 0x54, 0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x10, 0xb8, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, - 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, - 0x75, 0x6d, 0x10, 0xb9, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, - 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, - 0xba, 0x07, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, - 0x6d, 0x70, 0x4e, 0x65, 0x69, 0x67, 0x68, 0x62, 0x6f, 0x72, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, - 0x65, 0x72, 0x79, 0x4c, 0x6f, 0x6f, 0x70, 0x62, 0x61, 0x63, 0x6b, 0x10, 0xbb, 0x07, 0x12, 0x1c, - 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x55, 0x6e, - 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x10, 0xbc, 0x07, 0x12, 0x22, 0x0a, 0x1d, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x54, 0x72, 0x75, 0x6e, - 0x63, 0x61, 0x74, 0x65, 0x64, 0x49, 0x70, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xbd, 0x07, - 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, - 0x4f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x70, 0x48, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x10, 0xbe, 0x07, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x49, 0x63, 0x6d, 0x70, 0x4e, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x10, 0xbf, 0x07, - 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x6f, 0x45, 0x72, 0x72, 0x6f, - 0x72, 0x10, 0xc0, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x10, 0xc1, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x61, 0x74, - 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0xc2, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x50, 0x61, 0x74, 0x68, 0x52, 0x61, 0x74, - 0x65, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0xc3, 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, - 0x10, 0xc4, 0x07, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, - 0x63, 0x6d, 0x70, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xc5, 0x07, 0x12, 0x1f, 0x0a, - 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x42, 0x75, 0x66, - 0x66, 0x65, 0x72, 0x54, 0x6f, 0x6f, 0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x10, 0xc6, 0x07, 0x12, 0x23, - 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x41, 0x6e, - 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x79, 0x44, 0x61, 0x74, 0x61, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x10, 0xc7, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, - 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x48, 0x6f, 0x70, 0x4c, - 0x69, 0x6d, 0x69, 0x74, 0x10, 0xc8, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x43, 0x6f, - 0x64, 0x65, 0x10, 0xc9, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, - 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x74, 0x4c, 0x69, - 0x6e, 0x6b, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0xca, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x54, 0x72, 0x75, 0x6e, 0x63, 0x61, - 0x74, 0x65, 0x64, 0x4e, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xcb, 0x07, 0x12, 0x2b, - 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, - 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x4c, 0x69, 0x6e, 0x6b, 0x41, 0x64, 0x64, 0x72, 0x10, 0xcc, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, - 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x4d, 0x74, 0x75, 0x10, 0xcd, 0x07, 0x12, 0x2e, 0x0a, - 0x29, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, - 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x49, - 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xce, 0x07, 0x12, 0x2d, 0x0a, - 0x28, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, - 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x49, 0x6e, - 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xcf, 0x07, 0x12, 0x22, 0x0a, 0x1d, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, - 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x52, 0x64, 0x6e, 0x73, 0x73, 0x10, 0xd0, 0x07, - 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, - 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x44, 0x6e, 0x73, 0x73, - 0x6c, 0x10, 0xd1, 0x07, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x49, 0x63, 0x6d, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x50, 0x61, 0x72, 0x73, 0x69, 0x6e, - 0x67, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xd2, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x44, 0x69, 0x73, 0x61, 0x6c, - 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0xd3, 0x07, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x52, - 0x6f, 0x75, 0x74, 0x65, 0x72, 0x41, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x6d, 0x65, - 0x6e, 0x74, 0x10, 0xd4, 0x07, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, - 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x44, - 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x4c, 0x69, 0x6e, 0x6b, 0x10, 0xd5, 0x07, 0x12, - 0x33, 0x0a, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, - 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x44, 0x65, - 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x72, 0x54, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x10, 0xd6, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x54, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x10, 0xd7, 0x07, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4e, 0x61, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x73, - 0x74, 0x41, 0x6e, 0x64, 0x53, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x65, 0x64, 0x10, 0xd8, 0x07, - 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, - 0x4e, 0x64, 0x4c, 0x69, 0x6e, 0x6b, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, - 0x73, 0x73, 0x49, 0x73, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0xd9, 0x07, 0x12, 0x25, 0x0a, 0x20, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x44, 0x75, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x74, 0x65, 0x45, 0x63, 0x68, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x10, 0xda, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, - 0x63, 0x6d, 0x70, 0x4e, 0x6f, 0x74, 0x41, 0x50, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, - 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x10, 0xdb, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, - 0x4d, 0x6c, 0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x10, 0xdc, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, - 0x69, 0x64, 0x4d, 0x6c, 0x64, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x10, 0xdd, 0x07, 0x12, 0x28, - 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4c, 0x6f, - 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x64, 0x4d, 0x6c, 0x64, 0x52, - 0x65, 0x70, 0x6f, 0x72, 0x74, 0x10, 0xde, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4e, 0x6f, 0x74, 0x4c, 0x6f, 0x63, 0x61, 0x6c, - 0x6c, 0x79, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x64, 0x10, 0xdf, 0x07, 0x12, 0x1d, 0x0a, - 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x49, 0x6e, 0x76, 0x61, - 0x6c, 0x69, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x10, 0xe0, 0x07, 0x12, 0x1d, 0x0a, 0x18, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, - 0x69, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x10, 0xe1, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x44, 0x6c, 0x53, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x49, 0x73, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0xe2, 0x07, 0x12, 0x22, 0x0a, 0x1d, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x4e, 0x6f, 0x74, 0x4c, 0x6f, - 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x64, 0x10, 0xe3, 0x07, - 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4e, 0x6c, 0x43, 0x6c, - 0x69, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, 0x63, 0x61, 0x72, 0x64, 0x10, 0xe4, 0x07, 0x12, 0x2b, - 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, - 0x55, 0x72, 0x6f, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x45, 0x78, - 0x63, 0x65, 0x65, 0x64, 0x73, 0x4d, 0x74, 0x75, 0x10, 0xe5, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x46, 0x72, 0x61, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x10, 0xe6, 0x07, 0x12, 0x24, - 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x46, 0x69, 0x72, 0x73, 0x74, 0x46, - 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, - 0x65, 0x10, 0xe7, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, - 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x69, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, - 0xe8, 0x07, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, - 0x6d, 0x70, 0x4a, 0x75, 0x6d, 0x62, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x10, 0xe9, 0x07, 0x12, 0x19, - 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x53, 0x77, 0x55, 0x73, 0x6f, 0x46, - 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xea, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x55, 0x6e, 0x73, - 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x10, 0xb0, 0x09, 0x12, 0x23, 0x0a, 0x1e, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, - 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x73, 0x74, 0x10, 0xb1, 0x09, - 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x48, 0x65, - 0x61, 0x64, 0x65, 0x72, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0xb2, 0x09, 0x12, 0x1e, - 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x43, 0x68, 0x65, 0x63, - 0x6b, 0x73, 0x75, 0x6d, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0xb3, 0x09, 0x12, 0x1f, - 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x45, 0x6e, 0x64, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xb4, 0x09, 0x12, - 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x43, 0x6f, 0x6e, - 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x10, 0xb5, 0x09, 0x12, 0x1b, 0x0a, - 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x65, 0x73, 0x73, 0x69, - 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x10, 0xb6, 0x09, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x49, - 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xb7, 0x09, 0x12, 0x19, 0x0a, 0x14, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x41, 0x63, 0x6b, 0x49, 0x6e, 0x76, - 0x61, 0x6c, 0x69, 0x64, 0x10, 0xb8, 0x09, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x79, 0x6e, - 0x10, 0xb9, 0x09, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, - 0x5f, 0x52, 0x73, 0x74, 0x10, 0xba, 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x79, 0x6e, 0x52, 0x63, 0x76, 0x64, 0x53, 0x79, 0x6e, 0x10, - 0xbb, 0x09, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, - 0x53, 0x69, 0x6d, 0x75, 0x6c, 0x74, 0x61, 0x6e, 0x65, 0x6f, 0x75, 0x73, 0x43, 0x6f, 0x6e, 0x6e, - 0x65, 0x63, 0x74, 0x10, 0xbc, 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, - 0x4e, 0x45, 0x54, 0x5f, 0x50, 0x61, 0x77, 0x73, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xbd, - 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x4c, - 0x61, 0x6e, 0x64, 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x10, 0xbe, 0x09, 0x12, 0x1a, 0x0a, 0x15, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x4d, 0x69, 0x73, 0x73, 0x65, 0x64, - 0x52, 0x65, 0x73, 0x65, 0x74, 0x10, 0xbf, 0x09, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x4f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, - 0x64, 0x6f, 0x77, 0x10, 0xc0, 0x09, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, - 0x4e, 0x45, 0x54, 0x5f, 0x44, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x65, 0x67, - 0x6d, 0x65, 0x6e, 0x74, 0x10, 0xc1, 0x09, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x57, 0x69, 0x6e, 0x64, 0x6f, - 0x77, 0x10, 0xc2, 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, - 0x54, 0x5f, 0x54, 0x63, 0x62, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x10, 0xc3, 0x09, 0x12, - 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x46, 0x69, 0x6e, - 0x57, 0x61, 0x69, 0x74, 0x32, 0x10, 0xc4, 0x09, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x52, 0x65, 0x61, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x79, - 0x43, 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x10, 0xc5, 0x09, 0x12, 0x1a, 0x0a, 0x15, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x46, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, - 0x69, 0x76, 0x65, 0x64, 0x10, 0xc6, 0x09, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x76, - 0x61, 0x6c, 0x69, 0x64, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x10, 0xc7, 0x09, 0x12, 0x1f, 0x0a, 0x1a, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, 0x63, 0x62, 0x4e, 0x6f, 0x74, - 0x49, 0x6e, 0x54, 0x63, 0x62, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x10, 0xc8, 0x09, 0x12, 0x32, 0x0a, - 0x2d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, 0x69, 0x6d, 0x65, 0x57, - 0x61, 0x69, 0x74, 0x54, 0x63, 0x62, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x52, 0x73, - 0x74, 0x4f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x10, 0xc9, - 0x09, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, - 0x69, 0x6d, 0x65, 0x57, 0x61, 0x69, 0x74, 0x54, 0x63, 0x62, 0x53, 0x79, 0x6e, 0x41, 0x6e, 0x64, - 0x4f, 0x74, 0x68, 0x65, 0x72, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x10, 0xca, 0x09, 0x12, 0x1a, 0x0a, - 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, 0x69, 0x6d, 0x65, 0x57, - 0x61, 0x69, 0x74, 0x54, 0x63, 0x62, 0x10, 0xcb, 0x09, 0x12, 0x2e, 0x0a, 0x29, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x79, 0x6e, 0x41, 0x63, 0x6b, 0x57, 0x69, 0x74, - 0x68, 0x46, 0x61, 0x73, 0x74, 0x6f, 0x70, 0x65, 0x6e, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xcc, 0x09, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x50, 0x61, 0x75, 0x73, 0x65, 0x41, 0x63, 0x63, 0x65, - 0x70, 0x74, 0x10, 0xcd, 0x09, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, - 0x45, 0x54, 0x5f, 0x53, 0x79, 0x6e, 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x10, 0xce, 0x09, 0x12, - 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x41, 0x63, 0x63, - 0x65, 0x70, 0x74, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xcf, 0x09, - 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x41, 0x63, - 0x63, 0x65, 0x70, 0x74, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, - 0xd0, 0x09, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, - 0x78, 0x5f, 0x50, 0x61, 0x72, 0x73, 0x69, 0x6e, 0x67, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, - 0x10, 0x95, 0x0a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, - 0x75, 0x78, 0x5f, 0x46, 0x69, 0x72, 0x73, 0x74, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x4d, 0x69, 0x73, 0x73, 0x10, 0x96, 0x0a, 0x12, 0x32, 0x0a, 0x2d, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x49, 0x43, 0x4d, 0x50, 0x45, 0x72, 0x72, 0x6f, 0x72, - 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x97, 0x0a, 0x12, 0x2e, 0x0a, 0x29, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x49, 0x43, 0x4d, 0x50, 0x45, - 0x72, 0x72, 0x6f, 0x72, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4e, - 0x6f, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0x98, 0x0a, 0x12, 0x34, 0x0a, 0x2f, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x45, 0x78, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x48, 0x61, 0x69, 0x72, 0x70, 0x69, 0x6e, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, - 0x70, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x99, - 0x0a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, - 0x5f, 0x4e, 0x6f, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x69, - 0x63, 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x10, 0x9a, 0x0a, 0x12, 0x28, 0x0a, 0x23, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4e, 0x65, 0x78, 0x74, 0x68, - 0x6f, 0x70, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, - 0x72, 0x65, 0x10, 0x9b, 0x0a, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, - 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x43, 0x6c, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x46, 0x61, 0x69, 0x6c, - 0x75, 0x72, 0x65, 0x10, 0x9c, 0x0a, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, - 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, - 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x9d, 0x0a, 0x12, 0x21, 0x0a, 0x1c, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x48, 0x6f, 0x70, 0x4c, 0x69, - 0x6d, 0x69, 0x74, 0x45, 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x9e, 0x0a, 0x12, 0x24, - 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x50, 0x61, - 0x63, 0x6b, 0x65, 0x74, 0x42, 0x69, 0x67, 0x67, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e, 0x4d, 0x54, - 0x55, 0x10, 0x9f, 0x0a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, - 0x4d, 0x75, 0x78, 0x5f, 0x55, 0x6e, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x52, 0x6f, - 0x75, 0x74, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, - 0x10, 0xa0, 0x0a, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, - 0x75, 0x78, 0x5f, 0x4e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x10, 0xa1, 0x0a, 0x12, 0x27, 0x0a, - 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x53, 0x65, 0x73, - 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, - 0x75, 0x72, 0x65, 0x10, 0xa2, 0x0a, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, - 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, 0x70, 0x4e, 0x6f, 0x74, - 0x4f, 0x76, 0x65, 0x72, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x65, - 0x72, 0x66, 0x61, 0x63, 0x65, 0x10, 0xa3, 0x0a, 0x12, 0x38, 0x0a, 0x33, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, 0x70, 0x45, - 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, - 0x4d, 0x69, 0x73, 0x73, 0x4e, 0x41, 0x54, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x10, - 0xa4, 0x0a, 0x12, 0x2f, 0x0a, 0x2a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, - 0x78, 0x5f, 0x4e, 0x41, 0x54, 0x49, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x43, 0x61, 0x6e, 0x74, 0x42, - 0x65, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, 0x70, - 0x10, 0xa5, 0x0a, 0x12, 0x36, 0x0a, 0x31, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, - 0x75, 0x78, 0x5f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x61, 0x62, 0x6c, - 0x65, 0x49, 0x6e, 0x49, 0x74, 0x73, 0x41, 0x72, 0x72, 0x69, 0x76, 0x61, 0x6c, 0x43, 0x6f, 0x6d, - 0x70, 0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x10, 0xa6, 0x0a, 0x12, 0x34, 0x0a, 0x2f, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x50, 0x61, 0x63, 0x6b, 0x65, - 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, - 0x6f, 0x6c, 0x4e, 0x6f, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x10, 0xa7, - 0x0a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, - 0x5f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x73, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, - 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x10, 0xa8, 0x0a, 0x12, 0x3a, 0x0a, 0x35, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x50, 0x61, 0x63, 0x6b, 0x65, - 0x74, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x50, 0x61, 0x6e, - 0x64, 0x50, 0x6f, 0x72, 0x74, 0x4e, 0x6f, 0x74, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, - 0x6f, 0x4e, 0x41, 0x54, 0x10, 0xa9, 0x0a, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4d, 0x75, 0x78, 0x52, 0x65, 0x6a, 0x65, 0x63, 0x74, - 0x10, 0xaa, 0x0a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, - 0x75, 0x78, 0x5f, 0x44, 0x69, 0x70, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, 0x61, 0x69, 0x6c, - 0x75, 0x72, 0x65, 0x10, 0xab, 0x0a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, - 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4d, 0x75, 0x78, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, - 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xac, 0x0a, - 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, - 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x44, 0x69, 0x61, 0x67, 0x50, 0x61, 0x63, 0x6b, 0x65, - 0x74, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x54, 0x79, 0x70, 0x65, 0x10, 0xad, 0x0a, 0x12, 0x25, 0x0a, - 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x44, 0x69, 0x61, - 0x67, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x73, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, - 0x74, 0x10, 0xae, 0x0a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, - 0x4d, 0x75, 0x78, 0x5f, 0x55, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x48, 0x61, 0x6e, 0x64, - 0x6c, 0x65, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x10, 0xaf, 0x0a, 0x12, 0x16, 0x0a, - 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x42, 0x61, 0x64, 0x53, - 0x70, 0x69, 0x10, 0xf9, 0x0a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, - 0x73, 0x65, 0x63, 0x5f, 0x53, 0x41, 0x4c, 0x69, 0x66, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x45, 0x78, - 0x70, 0x69, 0x72, 0x65, 0x64, 0x10, 0xfa, 0x0a, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x57, 0x72, 0x6f, 0x6e, 0x67, 0x53, 0x41, 0x10, 0xfb, - 0x0a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, - 0x52, 0x65, 0x70, 0x6c, 0x61, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x46, 0x61, 0x69, 0x6c, 0x65, - 0x64, 0x10, 0xfc, 0x0a, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, - 0x65, 0x63, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, - 0x10, 0xfd, 0x0a, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, - 0x63, 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x69, 0x74, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xfe, 0x0a, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x54, 0x65, 0x78, - 0x74, 0x44, 0x72, 0x6f, 0x70, 0x10, 0xff, 0x0a, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x41, 0x75, 0x74, 0x68, 0x46, 0x69, 0x72, 0x65, 0x77, - 0x61, 0x6c, 0x6c, 0x44, 0x72, 0x6f, 0x70, 0x10, 0x80, 0x0b, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, - 0x65, 0x44, 0x72, 0x6f, 0x70, 0x10, 0x81, 0x0b, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x42, 0x6c, 0x6f, 0x63, - 0x6b, 0x10, 0x82, 0x0b, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, - 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, - 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x73, 0x74, 0x10, 0x83, 0x0b, 0x12, 0x22, 0x0a, 0x1d, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, - 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x10, 0x84, 0x0b, - 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, - 0x6f, 0x73, 0x70, 0x5f, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, - 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0x85, 0x0b, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x4d, 0x61, 0x78, 0x45, - 0x6e, 0x74, 0x72, 0x69, 0x65, 0x73, 0x10, 0x86, 0x0b, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x4b, 0x65, 0x79, - 0x6d, 0x6f, 0x64, 0x4e, 0x6f, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x87, 0x0b, - 0x12, 0x2c, 0x0a, 0x27, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, - 0x6f, 0x73, 0x70, 0x5f, 0x4d, 0x61, 0x78, 0x50, 0x65, 0x72, 0x49, 0x70, 0x52, 0x61, 0x74, 0x65, - 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x73, 0x10, 0x88, 0x0b, 0x12, 0x18, - 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x4e, 0x6f, 0x4d, - 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10, 0x89, 0x0b, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x55, 0x6e, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, - 0x66, 0x75, 0x6c, 0x10, 0x8a, 0x0b, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, - 0x65, 0x74, 0x43, 0x78, 0x5f, 0x4e, 0x65, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x4c, 0x61, - 0x79, 0x6f, 0x75, 0x74, 0x50, 0x61, 0x72, 0x73, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, - 0x10, 0xdd, 0x0b, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, - 0x78, 0x5f, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, - 0x75, 0x6d, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xde, 0x0b, 0x12, 0x1c, 0x0a, 0x17, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x4e, 0x69, 0x63, 0x51, 0x75, - 0x65, 0x75, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x10, 0xdf, 0x0b, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, - 0x4e, 0x65, 0x74, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, - 0xe0, 0x0b, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, - 0x5f, 0x4c, 0x53, 0x4f, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xe1, 0x0b, 0x12, 0x1a, - 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x55, 0x53, 0x4f, - 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xe2, 0x0b, 0x12, 0x32, 0x0a, 0x2d, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x42, - 0x6f, 0x75, 0x6e, 0x63, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x41, 0x6e, 0x64, 0x50, - 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x10, 0xe3, 0x0b, 0x12, 0x14, - 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x42, 0x65, 0x67, 0x69, - 0x6e, 0x10, 0xb8, 0x17, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, - 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x10, - 0xb9, 0x17, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, - 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xba, 0x17, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x56, - 0x65, 0x72, 0x62, 0x10, 0xbb, 0x17, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x55, 0x72, 0x6c, 0x10, 0xbc, - 0x17, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xbd, 0x17, 0x12, - 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, - 0x72, 0x72, 0x6f, 0x72, 0x48, 0x6f, 0x73, 0x74, 0x10, 0xbe, 0x17, 0x12, 0x19, 0x0a, 0x14, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, - 0x4e, 0x75, 0x6d, 0x10, 0xbf, 0x17, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, - 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc0, 0x17, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc1, 0x17, 0x12, 0x22, - 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, - 0x72, 0x6f, 0x72, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x10, - 0xc2, 0x17, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, - 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64, 0x64, 0x65, 0x6e, - 0x55, 0x72, 0x6c, 0x10, 0xc3, 0x17, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4e, 0x6f, 0x74, 0x46, 0x6f, - 0x75, 0x6e, 0x64, 0x10, 0xc4, 0x17, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x65, - 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc5, 0x17, 0x12, 0x28, 0x0a, 0x23, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, - 0x50, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, - 0x65, 0x64, 0x10, 0xc6, 0x17, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, - 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, - 0x54, 0x6f, 0x6f, 0x4c, 0x61, 0x72, 0x67, 0x65, 0x10, 0xc7, 0x17, 0x12, 0x1f, 0x0a, 0x1a, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, - 0x55, 0x72, 0x6c, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc8, 0x17, 0x12, 0x29, 0x0a, 0x24, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, - 0x72, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x6f, 0x74, 0x53, 0x61, 0x74, 0x69, 0x73, 0x66, 0x69, - 0x61, 0x62, 0x6c, 0x65, 0x10, 0xc9, 0x17, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x69, 0x73, 0x64, - 0x69, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xca, - 0x17, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x53, 0x65, - 0x72, 0x76, 0x65, 0x72, 0x10, 0xcb, 0x17, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4e, 0x6f, 0x74, 0x49, - 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x10, 0xcc, 0x17, 0x12, 0x21, 0x0a, - 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, - 0x6f, 0x72, 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x10, 0xcd, 0x17, - 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, - 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c, - 0x69, 0x6d, 0x69, 0x74, 0x10, 0xce, 0x17, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x61, 0x70, 0x69, - 0x64, 0x46, 0x61, 0x69, 0x6c, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, - 0xcf, 0x17, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, - 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x51, 0x75, - 0x65, 0x75, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x10, 0xd0, 0x17, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x44, - 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x79, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x10, 0xd1, - 0x17, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x79, - 0x41, 0x70, 0x70, 0x10, 0xd2, 0x17, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4a, 0x6f, 0x62, 0x4f, 0x62, - 0x6a, 0x65, 0x63, 0x74, 0x46, 0x69, 0x72, 0x65, 0x64, 0x10, 0xd3, 0x17, 0x12, 0x21, 0x0a, 0x1c, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, - 0x72, 0x41, 0x70, 0x70, 0x50, 0x6f, 0x6f, 0x6c, 0x42, 0x75, 0x73, 0x79, 0x10, 0xd4, 0x17, 0x12, - 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, - 0x72, 0x72, 0x6f, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0xd5, 0x17, 0x12, 0x1a, - 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, - 0x72, 0x6f, 0x72, 0x5f, 0x45, 0x6e, 0x64, 0x10, 0xd6, 0x17, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, - 0x6c, 0x74, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x10, 0xc8, 0x1a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, - 0x6c, 0x74, 0x55, 0x73, 0x65, 0x72, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x10, 0xc9, 0x1a, 0x12, 0x23, - 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, - 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x10, 0xca, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, - 0x74, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x10, 0xcb, 0x1a, 0x12, - 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, - 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4e, 0x6f, 0x74, - 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xcc, 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, - 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x4d, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x10, 0xcd, - 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x4e, - 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xce, 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, - 0x6c, 0x74, 0x44, 0x61, 0x74, 0x61, 0x41, 0x66, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x64, 0x10, 0xcf, - 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x61, 0x74, 0x68, 0x4e, 0x6f, 0x74, - 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xd0, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, - 0x48, 0x61, 0x6c, 0x66, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, - 0xd1, 0x1a, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, - 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x70, - 0x61, 0x74, 0x69, 0x62, 0x6c, 0x65, 0x41, 0x75, 0x74, 0x68, 0x10, 0xd2, 0x1a, 0x12, 0x24, 0x0a, - 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, - 0x46, 0x61, 0x75, 0x6c, 0x74, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x33, - 0x10, 0xd3, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, - 0x74, 0x43, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x10, 0xd4, 0x1a, 0x12, - 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, - 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4e, 0x61, 0x6d, - 0x65, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x10, 0xd5, 0x1a, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, - 0x74, 0x49, 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x53, 0x65, 0x6e, 0x64, 0x10, 0xd6, 0x1a, 0x12, - 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, - 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x75, 0x73, 0x68, 0x55, 0x70, 0x70, 0x65, 0x72, - 0x41, 0x74, 0x74, 0x61, 0x63, 0x68, 0x10, 0xd7, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, - 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x55, 0x70, 0x70, 0x65, 0x72, 0x41, 0x74, 0x74, 0x61, - 0x63, 0x68, 0x10, 0xd8, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, - 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x63, 0x74, - 0x69, 0x76, 0x65, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0xd9, - 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, - 0x74, 0x79, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xda, 0x1a, 0x12, 0x27, 0x0a, - 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, - 0x46, 0x61, 0x75, 0x6c, 0x74, 0x55, 0x6e, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x54, - 0x61, 0x69, 0x6c, 0x10, 0xdb, 0x1a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x72, - 0x75, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x10, 0xdc, 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, - 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x6f, 0x6c, 0x64, 0x10, 0xdd, - 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x65, 0x64, 0x10, 0xde, 0x1a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, - 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, - 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xdf, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, - 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x65, 0x64, - 0x10, 0xe0, 0x1a, 0x12, 0x2e, 0x0a, 0x29, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, - 0x10, 0xe1, 0x1a, 0x12, 0x31, 0x0a, 0x2c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45, 0x6e, 0x63, 0x6f, 0x64, - 0x69, 0x6e, 0x67, 0x10, 0xe2, 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4c, 0x69, 0x6e, 0x65, 0x10, 0xe3, 0x1a, 0x12, 0x27, 0x0a, - 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, - 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, - 0x64, 0x65, 0x72, 0x10, 0xe4, 0x1a, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, - 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x10, 0xe5, 0x1a, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, - 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x53, 0x74, 0x61, 0x72, 0x74, 0x10, 0xe6, 0x1a, 0x12, 0x24, 0x0a, - 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, - 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, - 0x10, 0xe7, 0x1a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x68, 0x75, 0x6e, 0x6b, - 0x53, 0x74, 0x6f, 0x70, 0x10, 0xe8, 0x1a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x48, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x41, 0x66, 0x74, 0x65, 0x72, 0x54, 0x72, 0x61, 0x69, 0x6c, - 0x65, 0x72, 0x73, 0x10, 0xe9, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x48, 0x65, - 0x61, 0x64, 0x65, 0x72, 0x73, 0x41, 0x66, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x64, 0x10, 0xea, 0x1a, - 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, - 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x45, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x54, - 0x72, 0x61, 0x69, 0x6c, 0x65, 0x72, 0x10, 0xeb, 0x1a, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, - 0x74, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, - 0x67, 0x10, 0xec, 0x1a, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, - 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x75, 0x6c, 0x74, - 0x69, 0x70, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x6f, 0x64, 0x69, - 0x6e, 0x67, 0x73, 0x10, 0xed, 0x1a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, - 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x75, - 0x73, 0x68, 0x42, 0x6f, 0x64, 0x79, 0x10, 0xee, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, - 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x41, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x65, 0x64, - 0x10, 0xef, 0x1a, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x61, 0x6c, 0x66, 0x6f, - 0x72, 0x6d, 0x65, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x10, 0xf0, 0x1a, 0x12, 0x2e, 0x0a, 0x29, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, - 0x75, 0x6c, 0x74, 0x44, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, - 0x4f, 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x10, 0xf1, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, - 0x75, 0x6c, 0x74, 0x49, 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x4e, 0x61, 0x6d, 0x65, 0x10, 0xf2, 0x1a, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x49, - 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, - 0x65, 0x10, 0xf3, 0x1a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, - 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x6e, - 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, - 0x10, 0xf4, 0x1a, 0x12, 0x2c, 0x0a, 0x27, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x48, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x6c, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x10, 0xf5, - 0x1a, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, - 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x52, - 0x65, 0x61, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x79, 0x10, 0xf6, 0x1a, 0x12, 0x25, 0x0a, 0x20, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, - 0x61, 0x75, 0x6c, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x10, 0xf7, 0x1a, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x65, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0xf8, 0x1a, 0x12, 0x27, - 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, - 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x61, 0x74, 0x68, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, - 0x6f, 0x77, 0x65, 0x64, 0x10, 0xf9, 0x1a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, - 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, - 0x75, 0x73, 0x68, 0x48, 0x6f, 0x73, 0x74, 0x10, 0xfa, 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, - 0x6c, 0x74, 0x47, 0x6f, 0x61, 0x77, 0x61, 0x79, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, - 0x10, 0xfb, 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x62, 0x6f, 0x72, 0x74, - 0x4c, 0x65, 0x67, 0x61, 0x63, 0x79, 0x41, 0x70, 0x70, 0x10, 0xfc, 0x1a, 0x12, 0x30, 0x0a, 0x2b, - 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, - 0x61, 0x75, 0x6c, 0x74, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0xfd, 0x1a, 0x12, 0x2e, - 0x0a, 0x29, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, - 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x55, 0x70, - 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xfe, 0x1a, 0x12, 0x32, - 0x0a, 0x2d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, - 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4b, 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x48, - 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, - 0xff, 0x1a, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, - 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x4b, 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x10, 0x80, 0x1b, 0x12, 0x32, 0x0a, 0x2d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, - 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x72, 0x6f, 0x78, - 0x79, 0x43, 0x6f, 0x6e, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x69, 0x73, 0x61, 0x6c, - 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x81, 0x1b, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x43, 0x6f, 0x6e, - 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0x82, 0x1b, 0x12, 0x2c, 0x0a, 0x27, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, - 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x47, 0x6f, 0x69, 0x6e, - 0x67, 0x41, 0x77, 0x61, 0x79, 0x10, 0x83, 0x1b, 0x12, 0x33, 0x0a, 0x2e, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, - 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, - 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x84, 0x1b, 0x12, 0x30, 0x0a, - 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, - 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, - 0x74, 0x68, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x85, 0x1b, 0x12, - 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, - 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x72, 0x61, 0x69, 0x6c, 0x65, 0x72, 0x44, 0x69, - 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x86, 0x1b, 0x12, 0x1c, 0x0a, 0x17, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, - 0x75, 0x6c, 0x74, 0x45, 0x6e, 0x64, 0x10, 0x87, 0x1b, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, - 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x53, 0x75, - 0x70, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x10, 0x90, 0x1c, 0x12, 0x16, 0x0a, 0x11, 0x44, - 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, - 0x10, 0xd8, 0x1d, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, - 0x72, 0x10, 0xd9, 0x1d, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, - 0x70, 0x5f, 0x49, 0x6e, 0x73, 0x75, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x10, 0xda, 0x1d, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, - 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x48, - 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x10, 0xdb, 0x1d, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, - 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x4e, 0x6f, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, - 0x65, 0x64, 0x10, 0xdc, 0x1d, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, - 0x74, 0x70, 0x5f, 0x42, 0x61, 0x64, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x50, 0x61, 0x74, - 0x68, 0x10, 0xdd, 0x1d, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, - 0x70, 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, - 0xde, 0x1d, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, - 0x4e, 0x6f, 0x53, 0x75, 0x63, 0x68, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x10, 0xdf, 0x1d, - 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x50, 0x72, - 0x69, 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x4e, 0x6f, 0x74, 0x48, 0x65, 0x6c, 0x64, 0x10, 0xe0, - 0x1d, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x43, - 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x49, 0x6d, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x74, 0x65, - 0x10, 0xe1, 0x1d, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x4c, 0x6f, 0x67, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xe2, 0x1d, - 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x4e, 0x6f, - 0x53, 0x75, 0x63, 0x68, 0x4c, 0x6f, 0x67, 0x6f, 0x6e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, - 0x10, 0xe3, 0x1d, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, - 0x5f, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x44, 0x65, 0x6e, 0x69, 0x65, 0x64, 0x10, 0xe4, 0x1d, - 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x4e, 0x6f, - 0x4c, 0x6f, 0x67, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x10, 0xe5, 0x1d, 0x12, - 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x54, 0x69, 0x6d, - 0x65, 0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x41, 0x74, 0x44, 0x63, 0x10, - 0xe6, 0x1d, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, - 0x45, 0x6e, 0x64, 0x10, 0xa0, 0x1f, 0x42, 0x27, 0x5a, 0x25, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, - 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x2f, 0x72, - 0x65, 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x62, - 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +type EndpointStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + BytesReceived uint64 `protobuf:"varint,1,opt,name=BytesReceived,proto3" json:"BytesReceived,omitempty"` + BytesSent uint64 `protobuf:"varint,2,opt,name=BytesSent,proto3" json:"BytesSent,omitempty"` + DroppedPacketsIncoming uint64 `protobuf:"varint,3,opt,name=DroppedPacketsIncoming,proto3" json:"DroppedPacketsIncoming,omitempty"` + DroppedPacketsOutgoing uint64 `protobuf:"varint,4,opt,name=DroppedPacketsOutgoing,proto3" json:"DroppedPacketsOutgoing,omitempty"` + EndpointID string `protobuf:"bytes,5,opt,name=EndpointID,proto3" json:"EndpointID,omitempty"` + InstanceID string `protobuf:"bytes,6,opt,name=InstanceID,proto3" json:"InstanceID,omitempty"` + PacketsReceived uint64 `protobuf:"varint,7,opt,name=PacketsReceived,proto3" json:"PacketsReceived,omitempty"` + PacketsSent uint64 `protobuf:"varint,8,opt,name=PacketsSent,proto3" json:"PacketsSent,omitempty"` } -var ( - file_pkg_utils_metadata_windows_proto_rawDescOnce sync.Once - file_pkg_utils_metadata_windows_proto_rawDescData = file_pkg_utils_metadata_windows_proto_rawDesc -) +func (x *EndpointStats) Reset() { + *x = EndpointStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} -func file_pkg_utils_metadata_windows_proto_rawDescGZIP() []byte { - file_pkg_utils_metadata_windows_proto_rawDescOnce.Do(func() { - file_pkg_utils_metadata_windows_proto_rawDescData = protoimpl.X.CompressGZIP(file_pkg_utils_metadata_windows_proto_rawDescData) - }) - return file_pkg_utils_metadata_windows_proto_rawDescData -} - -var file_pkg_utils_metadata_windows_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_pkg_utils_metadata_windows_proto_msgTypes = make([]protoimpl.MessageInfo, 2) -var file_pkg_utils_metadata_windows_proto_goTypes = []any{ - (DNSType)(0), // 0: utils.DNSType - (DropReason)(0), // 1: utils.DropReason - (*RetinaMetadata)(nil), // 2: utils.RetinaMetadata - nil, // 3: utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry -} -var file_pkg_utils_metadata_windows_proto_depIdxs = []int32{ - 0, // 0: utils.RetinaMetadata.dns_type:type_name -> utils.DNSType - 1, // 1: utils.RetinaMetadata.drop_reason:type_name -> utils.DropReason - 3, // 2: utils.RetinaMetadata.previously_observed_tcp_flags:type_name -> utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry - 3, // [3:3] is the sub-list for method output_type - 3, // [3:3] is the sub-list for method input_type - 3, // [3:3] is the sub-list for extension type_name - 3, // [3:3] is the sub-list for extension extendee - 0, // [0:3] is the sub-list for field type_name -} - -func init() { file_pkg_utils_metadata_windows_proto_init() } -func file_pkg_utils_metadata_windows_proto_init() { - if File_pkg_utils_metadata_windows_proto != nil { - return +func (x *EndpointStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EndpointStats) ProtoMessage() {} + +func (x *EndpointStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms } - if !protoimpl.UnsafeEnabled { - file_pkg_utils_metadata_windows_proto_msgTypes[0].Exporter = func(v any, i int) any { - switch v := v.(*RetinaMetadata); i { + return mi.MessageOf(x) +} + +// Deprecated: Use EndpointStats.ProtoReflect.Descriptor instead. +func (*EndpointStats) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{1} +} + +func (x *EndpointStats) GetBytesReceived() uint64 { + if x != nil { + return x.BytesReceived + } + return 0 +} + +func (x *EndpointStats) GetBytesSent() uint64 { + if x != nil { + return x.BytesSent + } + return 0 +} + +func (x *EndpointStats) GetDroppedPacketsIncoming() uint64 { + if x != nil { + return x.DroppedPacketsIncoming + } + return 0 +} + +func (x *EndpointStats) GetDroppedPacketsOutgoing() uint64 { + if x != nil { + return x.DroppedPacketsOutgoing + } + return 0 +} + +func (x *EndpointStats) GetEndpointID() string { + if x != nil { + return x.EndpointID + } + return "" +} + +func (x *EndpointStats) GetInstanceID() string { + if x != nil { + return x.InstanceID + } + return "" +} + +func (x *EndpointStats) GetPacketsReceived() uint64 { + if x != nil { + return x.PacketsReceived + } + return 0 +} + +func (x *EndpointStats) GetPacketsSent() uint64 { + if x != nil { + return x.PacketsSent + } + return 0 +} + +type VfpTcpConnectionStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + VerifiedCount uint64 `protobuf:"varint,1,opt,name=VerifiedCount,proto3" json:"VerifiedCount,omitempty"` + TimedOutCount uint64 `protobuf:"varint,2,opt,name=TimedOutCount,proto3" json:"TimedOutCount,omitempty"` + ResetCount uint64 `protobuf:"varint,3,opt,name=ResetCount,proto3" json:"ResetCount,omitempty"` + ResetSynCount uint64 `protobuf:"varint,4,opt,name=ResetSynCount,proto3" json:"ResetSynCount,omitempty"` + ClosedFinCount uint64 `protobuf:"varint,5,opt,name=ClosedFinCount,proto3" json:"ClosedFinCount,omitempty"` + TcpHalfOpenTimeoutsCount uint64 `protobuf:"varint,6,opt,name=TcpHalfOpenTimeoutsCount,proto3" json:"TcpHalfOpenTimeoutsCount,omitempty"` + TimeWaitExpiredCount uint64 `protobuf:"varint,7,opt,name=TimeWaitExpiredCount,proto3" json:"TimeWaitExpiredCount,omitempty"` +} + +func (x *VfpTcpConnectionStats) Reset() { + *x = VfpTcpConnectionStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpTcpConnectionStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpTcpConnectionStats) ProtoMessage() {} + +func (x *VfpTcpConnectionStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpTcpConnectionStats.ProtoReflect.Descriptor instead. +func (*VfpTcpConnectionStats) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{2} +} + +func (x *VfpTcpConnectionStats) GetVerifiedCount() uint64 { + if x != nil { + return x.VerifiedCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetTimedOutCount() uint64 { + if x != nil { + return x.TimedOutCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetResetCount() uint64 { + if x != nil { + return x.ResetCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetResetSynCount() uint64 { + if x != nil { + return x.ResetSynCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetClosedFinCount() uint64 { + if x != nil { + return x.ClosedFinCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetTcpHalfOpenTimeoutsCount() uint64 { + if x != nil { + return x.TcpHalfOpenTimeoutsCount + } + return 0 +} + +func (x *VfpTcpConnectionStats) GetTimeWaitExpiredCount() uint64 { + if x != nil { + return x.TimeWaitExpiredCount + } + return 0 +} + +type VfpTcpPacketStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SynPacketCount uint64 `protobuf:"varint,1,opt,name=SynPacketCount,proto3" json:"SynPacketCount,omitempty"` + SynAckPacketCount uint64 `protobuf:"varint,2,opt,name=SynAckPacketCount,proto3" json:"SynAckPacketCount,omitempty"` + FinPacketCount uint64 `protobuf:"varint,3,opt,name=FinPacketCount,proto3" json:"FinPacketCount,omitempty"` + RstPacketCount uint64 `protobuf:"varint,4,opt,name=RstPacketCount,proto3" json:"RstPacketCount,omitempty"` +} + +func (x *VfpTcpPacketStats) Reset() { + *x = VfpTcpPacketStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpTcpPacketStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpTcpPacketStats) ProtoMessage() {} + +func (x *VfpTcpPacketStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpTcpPacketStats.ProtoReflect.Descriptor instead. +func (*VfpTcpPacketStats) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{3} +} + +func (x *VfpTcpPacketStats) GetSynPacketCount() uint64 { + if x != nil { + return x.SynPacketCount + } + return 0 +} + +func (x *VfpTcpPacketStats) GetSynAckPacketCount() uint64 { + if x != nil { + return x.SynAckPacketCount + } + return 0 +} + +func (x *VfpTcpPacketStats) GetFinPacketCount() uint64 { + if x != nil { + return x.FinPacketCount + } + return 0 +} + +func (x *VfpTcpPacketStats) GetRstPacketCount() uint64 { + if x != nil { + return x.RstPacketCount + } + return 0 +} + +type VfpPacketDropStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + AclDropPacketCount uint64 `protobuf:"varint,1,opt,name=AclDropPacketCount,proto3" json:"AclDropPacketCount,omitempty"` +} + +func (x *VfpPacketDropStats) Reset() { + *x = VfpPacketDropStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpPacketDropStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpPacketDropStats) ProtoMessage() {} + +func (x *VfpPacketDropStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpPacketDropStats.ProtoReflect.Descriptor instead. +func (*VfpPacketDropStats) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{4} +} + +func (x *VfpPacketDropStats) GetAclDropPacketCount() uint64 { + if x != nil { + return x.AclDropPacketCount + } + return 0 +} + +type VfpTcpStats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ConnectionCounters *VfpTcpConnectionStats `protobuf:"bytes,1,opt,name=ConnectionCounters,proto3" json:"ConnectionCounters,omitempty"` + PacketCounters *VfpTcpPacketStats `protobuf:"bytes,2,opt,name=PacketCounters,proto3" json:"PacketCounters,omitempty"` +} + +func (x *VfpTcpStats) Reset() { + *x = VfpTcpStats{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpTcpStats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpTcpStats) ProtoMessage() {} + +func (x *VfpTcpStats) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpTcpStats.ProtoReflect.Descriptor instead. +func (*VfpTcpStats) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{5} +} + +func (x *VfpTcpStats) GetConnectionCounters() *VfpTcpConnectionStats { + if x != nil { + return x.ConnectionCounters + } + return nil +} + +func (x *VfpTcpStats) GetPacketCounters() *VfpTcpPacketStats { + if x != nil { + return x.PacketCounters + } + return nil +} + +type VfpDirectedPortCounters struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Direction VfpDirection `protobuf:"varint,1,opt,name=direction,proto3,enum=utils.VfpDirection" json:"direction,omitempty"` + TcpCounters *VfpTcpStats `protobuf:"bytes,2,opt,name=TcpCounters,proto3" json:"TcpCounters,omitempty"` + DropCounters *VfpPacketDropStats `protobuf:"bytes,3,opt,name=DropCounters,proto3" json:"DropCounters,omitempty"` +} + +func (x *VfpDirectedPortCounters) Reset() { + *x = VfpDirectedPortCounters{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpDirectedPortCounters) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpDirectedPortCounters) ProtoMessage() {} + +func (x *VfpDirectedPortCounters) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpDirectedPortCounters.ProtoReflect.Descriptor instead. +func (*VfpDirectedPortCounters) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{6} +} + +func (x *VfpDirectedPortCounters) GetDirection() VfpDirection { + if x != nil { + return x.Direction + } + return VfpDirection_OUT +} + +func (x *VfpDirectedPortCounters) GetTcpCounters() *VfpTcpStats { + if x != nil { + return x.TcpCounters + } + return nil +} + +func (x *VfpDirectedPortCounters) GetDropCounters() *VfpPacketDropStats { + if x != nil { + return x.DropCounters + } + return nil +} + +type VfpPortStatsData struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + In *VfpDirectedPortCounters `protobuf:"bytes,1,opt,name=In,proto3" json:"In,omitempty"` + Out *VfpDirectedPortCounters `protobuf:"bytes,2,opt,name=Out,proto3" json:"Out,omitempty"` +} + +func (x *VfpPortStatsData) Reset() { + *x = VfpPortStatsData{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VfpPortStatsData) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VfpPortStatsData) ProtoMessage() {} + +func (x *VfpPortStatsData) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VfpPortStatsData.ProtoReflect.Descriptor instead. +func (*VfpPortStatsData) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{7} +} + +func (x *VfpPortStatsData) GetIn() *VfpDirectedPortCounters { + if x != nil { + return x.In + } + return nil +} + +func (x *VfpPortStatsData) GetOut() *VfpDirectedPortCounters { + if x != nil { + return x.Out + } + return nil +} + +type HNSStatsMetadata struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + EndpointStats *EndpointStats `protobuf:"bytes,1,opt,name=EndpointStats,proto3" json:"EndpointStats,omitempty"` + VfpPortStatsData *VfpPortStatsData `protobuf:"bytes,2,opt,name=VfpPortStatsData,proto3" json:"VfpPortStatsData,omitempty"` +} + +func (x *HNSStatsMetadata) Reset() { + *x = HNSStatsMetadata{} + if protoimpl.UnsafeEnabled { + mi := &file_metadata_windows_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *HNSStatsMetadata) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HNSStatsMetadata) ProtoMessage() {} + +func (x *HNSStatsMetadata) ProtoReflect() protoreflect.Message { + mi := &file_metadata_windows_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HNSStatsMetadata.ProtoReflect.Descriptor instead. +func (*HNSStatsMetadata) Descriptor() ([]byte, []int) { + return file_metadata_windows_proto_rawDescGZIP(), []int{8} +} + +func (x *HNSStatsMetadata) GetEndpointStats() *EndpointStats { + if x != nil { + return x.EndpointStats + } + return nil +} + +func (x *HNSStatsMetadata) GetVfpPortStatsData() *VfpPortStatsData { + if x != nil { + return x.VfpPortStatsData + } + return nil +} + +var File_metadata_windows_proto protoreflect.FileDescriptor + +var file_metadata_windows_proto_rawDesc = []byte{ + 0x0a, 0x16, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x77, 0x69, 0x6e, 0x64, 0x6f, + 0x77, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x22, + 0x86, 0x04, 0x0a, 0x0e, 0x52, 0x65, 0x74, 0x69, 0x6e, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0x12, 0x14, 0x0a, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0d, 0x52, 0x05, 0x62, 0x79, 0x74, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x08, 0x64, 0x6e, 0x73, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x0e, 0x2e, 0x75, 0x74, 0x69, + 0x6c, 0x73, 0x2e, 0x44, 0x4e, 0x53, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x64, 0x6e, 0x73, 0x54, + 0x79, 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x75, 0x6d, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x6e, 0x75, 0x6d, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x73, 0x12, 0x15, 0x0a, 0x06, 0x74, 0x63, 0x70, 0x5f, + 0x69, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x05, 0x74, 0x63, 0x70, 0x49, 0x64, 0x12, + 0x32, 0x0a, 0x0b, 0x64, 0x72, 0x6f, 0x70, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x11, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x44, 0x72, 0x6f, + 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x52, 0x0a, 0x64, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, + 0x73, 0x6f, 0x6e, 0x12, 0x3e, 0x0a, 0x1b, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, + 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, + 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x73, 0x12, 0x3a, 0x0a, 0x19, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, + 0x79, 0x5f, 0x6f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x17, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, + 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x42, 0x79, 0x74, 0x65, 0x73, 0x12, + 0x78, 0x0a, 0x1d, 0x70, 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x5f, 0x6f, 0x62, + 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x74, 0x63, 0x70, 0x5f, 0x66, 0x6c, 0x61, 0x67, 0x73, + 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x52, + 0x65, 0x74, 0x69, 0x6e, 0x61, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x50, 0x72, + 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, + 0x54, 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x1a, 0x70, + 0x72, 0x65, 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, + 0x64, 0x54, 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x1a, 0x4d, 0x0a, 0x1f, 0x50, 0x72, 0x65, + 0x76, 0x69, 0x6f, 0x75, 0x73, 0x6c, 0x79, 0x4f, 0x62, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x54, + 0x63, 0x70, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xcf, 0x02, 0x0a, 0x0d, 0x45, 0x6e, 0x64, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x42, 0x79, + 0x74, 0x65, 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x0d, 0x42, 0x79, 0x74, 0x65, 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, + 0x12, 0x1c, 0x0a, 0x09, 0x42, 0x79, 0x74, 0x65, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x09, 0x42, 0x79, 0x74, 0x65, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x12, 0x36, + 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, + 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x16, + 0x44, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x49, 0x6e, + 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x12, 0x36, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x70, 0x65, + 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x12, 0x1e, + 0x0a, 0x0a, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x1e, + 0x0a, 0x0a, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0a, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x12, 0x28, + 0x0a, 0x0f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, + 0x64, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, + 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x12, 0x20, 0x0a, 0x0b, 0x50, 0x61, 0x63, 0x6b, + 0x65, 0x74, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x73, 0x53, 0x65, 0x6e, 0x74, 0x22, 0xc1, 0x02, 0x0a, 0x15, 0x56, + 0x66, 0x70, 0x54, 0x63, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x56, 0x65, 0x72, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x56, 0x65, 0x72, + 0x69, 0x66, 0x69, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x54, 0x69, + 0x6d, 0x65, 0x64, 0x4f, 0x75, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x0d, 0x54, 0x69, 0x6d, 0x65, 0x64, 0x4f, 0x75, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x1e, 0x0a, 0x0a, 0x52, 0x65, 0x73, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x52, 0x65, 0x73, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x12, 0x24, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x79, 0x6e, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x79, + 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, + 0x46, 0x69, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, + 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x46, 0x69, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x3a, + 0x0a, 0x18, 0x54, 0x63, 0x70, 0x48, 0x61, 0x6c, 0x66, 0x4f, 0x70, 0x65, 0x6e, 0x54, 0x69, 0x6d, + 0x65, 0x6f, 0x75, 0x74, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, + 0x52, 0x18, 0x54, 0x63, 0x70, 0x48, 0x61, 0x6c, 0x66, 0x4f, 0x70, 0x65, 0x6e, 0x54, 0x69, 0x6d, + 0x65, 0x6f, 0x75, 0x74, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x32, 0x0a, 0x14, 0x54, 0x69, + 0x6d, 0x65, 0x57, 0x61, 0x69, 0x74, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x64, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x04, 0x52, 0x14, 0x54, 0x69, 0x6d, 0x65, 0x57, 0x61, + 0x69, 0x74, 0x45, 0x78, 0x70, 0x69, 0x72, 0x65, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0xb9, + 0x01, 0x0a, 0x11, 0x56, 0x66, 0x70, 0x54, 0x63, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x12, 0x26, 0x0a, 0x0e, 0x53, 0x79, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x53, 0x79, + 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x2c, 0x0a, 0x11, + 0x53, 0x79, 0x6e, 0x41, 0x63, 0x6b, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x11, 0x53, 0x79, 0x6e, 0x41, 0x63, 0x6b, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x46, 0x69, + 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x04, 0x52, 0x0e, 0x46, 0x69, 0x6e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x52, 0x73, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, + 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x52, 0x73, 0x74, 0x50, + 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x44, 0x0a, 0x12, 0x56, 0x66, + 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x72, 0x6f, 0x70, 0x53, 0x74, 0x61, 0x74, 0x73, + 0x12, 0x2e, 0x0a, 0x12, 0x41, 0x63, 0x6c, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x41, 0x63, + 0x6c, 0x44, 0x72, 0x6f, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, + 0x22, 0x9d, 0x01, 0x0a, 0x0b, 0x56, 0x66, 0x70, 0x54, 0x63, 0x70, 0x53, 0x74, 0x61, 0x74, 0x73, + 0x12, 0x4c, 0x0a, 0x12, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, + 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x75, + 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x54, 0x63, 0x70, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x12, 0x43, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x12, 0x40, + 0x0a, 0x0e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, + 0x66, 0x70, 0x54, 0x63, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, + 0x52, 0x0e, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, + 0x22, 0xc1, 0x01, 0x0a, 0x17, 0x56, 0x66, 0x70, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x50, 0x6f, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x12, 0x31, 0x0a, 0x09, + 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x13, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x44, 0x69, 0x72, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x34, 0x0a, 0x0b, 0x54, 0x63, 0x70, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x65, 0x72, 0x73, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, + 0x54, 0x63, 0x70, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0b, 0x54, 0x63, 0x70, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x65, 0x72, 0x73, 0x12, 0x3d, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x75, 0x74, + 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x44, 0x72, 0x6f, + 0x70, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x65, 0x72, 0x73, 0x22, 0x74, 0x0a, 0x10, 0x56, 0x66, 0x70, 0x50, 0x6f, 0x72, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, 0x12, 0x2e, 0x0a, 0x02, 0x49, 0x6e, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, 0x70, + 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x6f, 0x72, 0x74, 0x43, 0x6f, 0x75, 0x6e, + 0x74, 0x65, 0x72, 0x73, 0x52, 0x02, 0x49, 0x6e, 0x12, 0x30, 0x0a, 0x03, 0x4f, 0x75, 0x74, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, + 0x70, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x6f, 0x72, 0x74, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x65, 0x72, 0x73, 0x52, 0x03, 0x4f, 0x75, 0x74, 0x22, 0x93, 0x01, 0x0a, 0x10, 0x48, + 0x4e, 0x53, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x12, + 0x3a, 0x0a, 0x0d, 0x45, 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x45, + 0x6e, 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x0d, 0x45, 0x6e, + 0x64, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x43, 0x0a, 0x10, 0x56, + 0x66, 0x70, 0x50, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x2e, 0x56, 0x66, + 0x70, 0x50, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, 0x52, 0x10, + 0x56, 0x66, 0x70, 0x50, 0x6f, 0x72, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x44, 0x61, 0x74, 0x61, + 0x2a, 0x1f, 0x0a, 0x0c, 0x56, 0x66, 0x70, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x55, 0x54, 0x10, 0x00, 0x12, 0x06, 0x0a, 0x02, 0x49, 0x4e, 0x10, + 0x01, 0x2a, 0x2f, 0x0a, 0x07, 0x44, 0x4e, 0x53, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, + 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x51, 0x55, 0x45, + 0x52, 0x59, 0x10, 0x01, 0x12, 0x0c, 0x0a, 0x08, 0x52, 0x45, 0x53, 0x50, 0x4f, 0x4e, 0x53, 0x45, + 0x10, 0x02, 0x2a, 0xe0, 0x69, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x61, 0x73, 0x6f, + 0x6e, 0x12, 0x10, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, + 0x6e, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x44, 0x61, 0x74, 0x61, 0x10, 0x01, 0x12, 0x16, 0x0a, 0x12, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x10, + 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, + 0x63, 0x65, 0x73, 0x10, 0x03, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x6f, + 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, 0x04, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x65, 0x64, 0x10, 0x05, 0x12, + 0x14, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x6f, 0x74, 0x41, 0x63, 0x63, 0x65, 0x70, + 0x74, 0x65, 0x64, 0x10, 0x06, 0x12, 0x0d, 0x0a, 0x09, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x75, + 0x73, 0x79, 0x10, 0x07, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x69, 0x6c, + 0x74, 0x65, 0x72, 0x65, 0x64, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, 0x64, 0x56, 0x4c, 0x41, 0x4e, 0x10, 0x09, 0x12, 0x19, + 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, + 0x7a, 0x65, 0x64, 0x56, 0x4c, 0x41, 0x4e, 0x10, 0x0a, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x4d, 0x41, + 0x43, 0x10, 0x0b, 0x12, 0x1d, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x61, 0x69, 0x6c, + 0x65, 0x64, 0x53, 0x65, 0x63, 0x75, 0x72, 0x69, 0x74, 0x79, 0x50, 0x6f, 0x6c, 0x69, 0x63, 0x79, + 0x10, 0x0c, 0x12, 0x1b, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x61, 0x69, 0x6c, 0x65, + 0x64, 0x50, 0x76, 0x6c, 0x61, 0x6e, 0x53, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x10, 0x0d, 0x12, + 0x0c, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x51, 0x6f, 0x73, 0x10, 0x0e, 0x12, 0x0e, 0x0a, + 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x10, 0x0f, 0x12, 0x14, 0x0a, + 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4d, 0x61, 0x63, 0x53, 0x70, 0x6f, 0x6f, 0x66, 0x69, 0x6e, + 0x67, 0x10, 0x10, 0x12, 0x12, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x68, 0x63, 0x70, + 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0x11, 0x12, 0x14, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x52, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0x12, 0x12, 0x17, 0x0a, + 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x72, 0x69, 0x64, 0x67, 0x65, 0x52, 0x65, 0x73, 0x65, + 0x72, 0x76, 0x65, 0x64, 0x10, 0x13, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, + 0x69, 0x72, 0x74, 0x75, 0x61, 0x6c, 0x53, 0x75, 0x62, 0x6e, 0x65, 0x74, 0x49, 0x64, 0x10, 0x14, + 0x12, 0x21, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x73, 0x73, 0x69, 0x6e, + 0x67, 0x10, 0x15, 0x12, 0x16, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x10, 0x16, 0x12, 0x14, 0x0a, 0x10, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4d, 0x54, 0x55, 0x4d, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x10, + 0x17, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x61, 0x74, 0x69, 0x76, 0x65, + 0x46, 0x77, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x10, 0x18, 0x12, 0x1a, 0x0a, 0x16, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x56, 0x6c, 0x61, 0x6e, 0x46, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x10, 0x19, 0x12, 0x17, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x44, 0x65, 0x73, 0x74, 0x4d, 0x61, 0x63, 0x10, 0x1a, + 0x12, 0x19, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4d, 0x61, 0x63, 0x10, 0x1b, 0x12, 0x1f, 0x0a, 0x1b, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x46, 0x69, 0x72, 0x73, 0x74, + 0x4e, 0x42, 0x54, 0x6f, 0x6f, 0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x10, 0x1c, 0x12, 0x0c, 0x0a, 0x08, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x57, 0x6e, 0x76, 0x10, 0x1d, 0x12, 0x13, 0x0a, 0x0f, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x74, 0x6f, 0x72, 0x6d, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0x1e, 0x12, + 0x15, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x6a, 0x65, 0x63, 0x74, 0x65, 0x64, + 0x49, 0x63, 0x6d, 0x70, 0x10, 0x1f, 0x12, 0x24, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x4c, 0x69, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x10, 0x20, 0x12, 0x14, 0x0a, 0x10, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x69, 0x63, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, + 0x10, 0x21, 0x12, 0x1b, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x61, 0x69, 0x6c, 0x65, + 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x10, 0x22, 0x12, + 0x1f, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x44, 0x61, + 0x74, 0x61, 0x46, 0x6c, 0x6f, 0x77, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x10, 0x23, + 0x12, 0x22, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x65, + 0x64, 0x49, 0x73, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x74, 0x61, 0x67, 0x67, + 0x65, 0x64, 0x10, 0x24, 0x12, 0x17, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x50, 0x44, 0x51, 0x75, 0x65, 0x75, 0x65, 0x10, 0x25, 0x12, 0x11, 0x0a, + 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4c, 0x6f, 0x77, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x10, 0x26, + 0x12, 0x0f, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x50, 0x61, 0x75, 0x73, 0x65, 0x10, 0xc9, + 0x01, 0x12, 0x0f, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x52, 0x65, 0x73, 0x65, 0x74, 0x10, + 0xca, 0x01, 0x12, 0x15, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x65, 0x6e, 0x64, 0x41, + 0x62, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x10, 0xcb, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x4e, 0x6f, 0x74, 0x42, 0x6f, 0x75, + 0x6e, 0x64, 0x10, 0xcc, 0x01, 0x12, 0x11, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xcd, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xce, + 0x01, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x6f, 0x73, 0x74, 0x4f, 0x75, + 0x74, 0x4f, 0x66, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10, 0xcf, 0x01, 0x12, 0x16, 0x0a, 0x11, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x54, 0x6f, 0x6f, 0x4c, 0x6f, 0x6e, + 0x67, 0x10, 0xd0, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x72, 0x61, + 0x6d, 0x65, 0x54, 0x6f, 0x6f, 0x53, 0x68, 0x6f, 0x72, 0x74, 0x10, 0xd1, 0x01, 0x12, 0x1a, 0x0a, + 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4c, 0x65, 0x6e, 0x67, 0x74, + 0x68, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xd2, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x43, 0x72, 0x63, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xd3, 0x01, 0x12, 0x1a, 0x0a, + 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x61, 0x64, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x43, 0x68, + 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x10, 0xd4, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x46, 0x63, 0x73, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xd5, 0x01, 0x12, 0x15, 0x0a, + 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x10, 0xd6, 0x01, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x65, 0x61, + 0x64, 0x51, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, 0x10, 0xd7, 0x01, 0x12, 0x18, 0x0a, 0x13, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x74, 0x61, 0x6c, 0x6c, 0x65, 0x64, 0x44, 0x69, 0x73, 0x63, + 0x61, 0x72, 0x64, 0x10, 0xd8, 0x01, 0x12, 0x11, 0x0a, 0x0c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x52, + 0x78, 0x51, 0x46, 0x75, 0x6c, 0x6c, 0x10, 0xd9, 0x01, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x50, 0x68, 0x79, 0x73, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x10, 0xda, 0x01, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x6d, 0x61, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x10, 0xdb, 0x01, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xdc, 0x01, + 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x65, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xdd, 0x01, 0x12, 0x16, 0x0a, 0x11, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x61, 0x64, 0x53, 0x69, 0x67, 0x6e, 0x61, 0x74, 0x75, 0x72, + 0x65, 0x10, 0xde, 0x01, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x43, 0x6f, 0x61, + 0x6c, 0x65, 0x73, 0x63, 0x69, 0x6e, 0x67, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xdf, 0x01, 0x12, + 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, 0x6c, 0x61, 0x6e, 0x53, 0x70, 0x6f, 0x6f, + 0x66, 0x69, 0x6e, 0x67, 0x10, 0xe1, 0x01, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x55, 0x6e, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x45, 0x74, 0x68, 0x65, 0x72, 0x54, 0x79, + 0x70, 0x65, 0x10, 0xe2, 0x01, 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, 0x70, + 0x6f, 0x72, 0x74, 0x44, 0x6f, 0x77, 0x6e, 0x10, 0xe3, 0x01, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x74, 0x65, 0x65, 0x72, 0x69, 0x6e, 0x67, 0x4d, 0x69, 0x73, 0x6d, 0x61, + 0x74, 0x63, 0x68, 0x10, 0xe4, 0x01, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4d, + 0x69, 0x63, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0x91, 0x03, + 0x12, 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, 0x66, 0x4e, 0x6f, 0x74, 0x52, 0x65, + 0x61, 0x64, 0x79, 0x10, 0x92, 0x03, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4d, + 0x69, 0x63, 0x72, 0x6f, 0x70, 0x6f, 0x72, 0x74, 0x4e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, + 0x10, 0x93, 0x03, 0x12, 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x56, 0x4d, 0x42, 0x75, + 0x73, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0x94, 0x03, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x4c, 0x6f, 0x6f, 0x70, 0x62, 0x61, 0x63, 0x6b, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x10, 0xd9, 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, + 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x53, 0x6e, 0x61, 0x70, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x10, 0xda, 0x04, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, + 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x45, 0x74, 0x68, 0x65, 0x72, 0x6e, 0x65, + 0x74, 0x54, 0x79, 0x70, 0x65, 0x10, 0xdb, 0x04, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xdc, 0x04, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x43, + 0x6f, 0x6e, 0x74, 0x69, 0x67, 0x75, 0x6f, 0x75, 0x73, 0x10, 0xdd, 0x04, 0x12, 0x23, 0x0a, 0x1e, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x44, + 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x10, 0xde, + 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x74, + 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, 0xdf, + 0x04, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x50, 0x72, 0x6f, + 0x76, 0x69, 0x64, 0x65, 0x72, 0x4e, 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, 0xe0, 0x04, + 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x4c, 0x73, 0x6f, 0x49, 0x6e, 0x66, 0x6f, 0x10, 0xe1, 0x04, 0x12, 0x1b, 0x0a, + 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, + 0x55, 0x73, 0x6f, 0x49, 0x6e, 0x66, 0x6f, 0x10, 0xe2, 0x04, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x46, 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4d, 0x65, 0x64, + 0x69, 0x75, 0x6d, 0x10, 0xe3, 0x04, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, + 0x4c, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x41, 0x72, 0x70, 0x48, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x10, 0xe4, 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, + 0x5f, 0x4e, 0x6f, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, + 0x63, 0x65, 0x10, 0xe5, 0x04, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, + 0x5f, 0x54, 0x6f, 0x6f, 0x4d, 0x61, 0x6e, 0x79, 0x4e, 0x65, 0x74, 0x42, 0x75, 0x66, 0x66, 0x65, + 0x72, 0x73, 0x10, 0xe6, 0x04, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x46, 0x4c, + 0x5f, 0x46, 0x6c, 0x73, 0x4e, 0x70, 0x69, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x44, 0x72, 0x6f, + 0x70, 0x10, 0xe7, 0x04, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x41, 0x72, 0x70, + 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0xbd, 0x05, 0x12, 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x41, 0x72, 0x70, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, 0x10, 0xbe, 0x05, 0x12, 0x15, + 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x44, 0x68, 0x63, 0x70, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x65, 0x72, 0x10, 0xbf, 0x05, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x6c, + 0x6f, 0x63, 0x6b, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x10, 0xc0, 0x05, 0x12, + 0x14, 0x0a, 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x4e, 0x6f, 0x6e, + 0x49, 0x70, 0x10, 0xc1, 0x05, 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x41, 0x72, + 0x70, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x10, 0xc2, 0x05, 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x76, 0x34, 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0xc3, 0x05, 0x12, + 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x76, 0x36, 0x47, 0x75, 0x61, 0x72, + 0x64, 0x10, 0xc4, 0x05, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4d, 0x61, 0x63, + 0x47, 0x75, 0x61, 0x72, 0x64, 0x10, 0xc5, 0x05, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x63, 0x61, 0x73, 0x74, 0x4e, 0x6f, 0x44, 0x65, 0x73, 0x74, + 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x10, 0xc6, 0x05, 0x12, 0x1e, 0x0a, 0x19, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x69, 0x63, 0x61, 0x73, 0x74, 0x4e, 0x6f, 0x44, 0x65, 0x73, + 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xc7, 0x05, 0x12, 0x1d, 0x0a, 0x18, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x55, 0x6e, 0x69, 0x63, 0x61, 0x73, 0x74, 0x50, 0x6f, 0x72, 0x74, 0x4e, + 0x6f, 0x74, 0x52, 0x65, 0x61, 0x64, 0x79, 0x10, 0xc8, 0x05, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x77, 0x69, 0x74, 0x63, 0x68, 0x43, 0x61, 0x6c, 0x6c, 0x62, 0x61, 0x63, + 0x6b, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xc9, 0x05, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x76, 0x36, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x72, + 0x10, 0xca, 0x05, 0x12, 0x13, 0x0a, 0x0e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x6e, 0x74, 0x65, + 0x72, 0x63, 0x65, 0x70, 0x74, 0x10, 0xcb, 0x05, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x63, 0x65, 0x70, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x10, + 0xcc, 0x05, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x44, 0x50, 0x47, 0x75, + 0x61, 0x72, 0x64, 0x10, 0xcd, 0x05, 0x12, 0x15, 0x0a, 0x10, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x50, + 0x6f, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x10, 0xce, 0x05, 0x12, 0x16, 0x0a, + 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x69, 0x63, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, + 0x65, 0x64, 0x10, 0xcf, 0x05, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, + 0x5f, 0x42, 0x61, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x10, 0x85, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, + 0x4e, 0x6f, 0x74, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, + 0x65, 0x64, 0x10, 0x86, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, + 0x5f, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, 0x6c, 0x55, 0x6e, 0x72, 0x65, 0x61, 0x63, 0x68, + 0x61, 0x62, 0x6c, 0x65, 0x10, 0x87, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x4e, 0x4c, 0x5f, 0x50, 0x6f, 0x72, 0x74, 0x55, 0x6e, 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, + 0x6c, 0x65, 0x10, 0x88, 0x07, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, + 0x5f, 0x42, 0x61, 0x64, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0x89, 0x07, 0x12, 0x1c, 0x0a, + 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4d, 0x61, 0x6c, 0x66, 0x6f, 0x72, 0x6d, + 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0x8a, 0x07, 0x12, 0x14, 0x0a, 0x0f, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x10, 0x8b, + 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x42, 0x65, 0x79, + 0x6f, 0x6e, 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x10, 0x8c, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x44, 0x72, 0x6f, 0x70, 0x10, 0x8d, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x4e, 0x4c, 0x5f, 0x54, 0x6f, 0x6f, 0x4d, 0x61, 0x6e, 0x79, 0x44, 0x65, 0x63, 0x61, 0x70, + 0x73, 0x75, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x10, 0x8e, 0x07, 0x12, 0x27, 0x0a, 0x22, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x69, 0x73, 0x74, + 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x50, 0x72, 0x6f, 0x68, 0x69, 0x62, 0x69, 0x74, + 0x65, 0x64, 0x10, 0x8f, 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, + 0x5f, 0x42, 0x61, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, 0x6d, 0x10, 0x90, 0x07, 0x12, + 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x50, 0x61, 0x74, 0x68, 0x4d, 0x61, 0x78, 0x10, 0x91, 0x07, 0x12, 0x1d, 0x0a, 0x18, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x48, 0x6f, 0x70, 0x4c, 0x69, 0x6d, 0x69, 0x74, + 0x45, 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x92, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x55, 0x6e, + 0x72, 0x65, 0x61, 0x63, 0x68, 0x61, 0x62, 0x6c, 0x65, 0x10, 0x93, 0x07, 0x12, 0x16, 0x0a, 0x11, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x73, 0x63, 0x50, 0x61, 0x63, 0x6b, 0x65, + 0x74, 0x10, 0x94, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, + 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, 0x64, 0x50, 0x61, 0x74, 0x68, 0x4d, 0x61, 0x78, 0x10, 0x95, + 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x62, + 0x69, 0x74, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x55, 0x6e, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65, + 0x64, 0x10, 0x96, 0x07, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, + 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x41, 0x62, 0x73, 0x6f, 0x72, 0x62, + 0x10, 0x97, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x44, + 0x6f, 0x6e, 0x74, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4d, 0x74, 0x75, 0x45, 0x78, + 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x98, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x4c, 0x65, 0x6e, 0x67, 0x74, + 0x68, 0x45, 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x99, 0x07, 0x12, 0x25, 0x0a, 0x20, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, + 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x69, 0x6d, 0x65, 0x6f, 0x75, 0x74, + 0x10, 0x9a, 0x07, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, + 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x52, 0x65, 0x73, 0x6f, 0x6c, 0x75, 0x74, 0x69, 0x6f, 0x6e, + 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x9b, 0x07, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x46, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x10, 0x9c, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, + 0x5f, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x73, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x9d, 0x07, 0x12, 0x1d, 0x0a, 0x18, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x44, 0x72, 0x6f, 0x70, 0x10, 0x9e, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x4f, 0x66, 0x66, 0x6c, 0x6f, 0x61, 0x64, 0x10, 0x9f, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x6f, 0x75, 0x74, 0x69, 0x6e, 0x67, 0x46, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa0, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x6e, 0x63, 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x79, 0x44, 0x61, 0x74, + 0x61, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa1, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x52, 0x61, 0x77, 0x44, 0x61, 0x74, 0x61, 0x46, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa2, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x4e, 0x4c, 0x5f, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xa3, 0x07, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4d, 0x6f, 0x64, 0x69, + 0x66, 0x69, 0x65, 0x64, 0x42, 0x75, 0x74, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x72, 0x77, 0x61, 0x72, + 0x64, 0x65, 0x64, 0x10, 0xa4, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, + 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x4e, 0x65, 0x78, 0x74, 0x48, 0x6f, + 0x70, 0x10, 0xa5, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, + 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x72, 0x74, 0x6d, + 0x65, 0x6e, 0x74, 0x10, 0xa6, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, + 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, + 0x61, 0x63, 0x65, 0x10, 0xa7, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, + 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x53, 0x75, 0x62, 0x49, 0x6e, 0x74, + 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x10, 0xa8, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x49, 0x6e, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x10, 0xa9, 0x07, 0x12, + 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, + 0x69, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, + 0x6c, 0x65, 0x64, 0x10, 0xaa, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, + 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x4e, 0x6f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x6e, + 0x65, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xab, 0x07, 0x12, 0x25, 0x0a, 0x20, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x55, 0x6e, 0x65, + 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x10, + 0xac, 0x07, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, + 0x73, 0x6e, 0x70, 0x69, 0x55, 0x6e, 0x73, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x49, + 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x10, 0xad, 0x07, 0x12, + 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, + 0x69, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4c, 0x73, 0x6f, 0x49, 0x6e, 0x66, 0x6f, 0x10, + 0xae, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, + 0x73, 0x6e, 0x70, 0x69, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x55, 0x73, 0x6f, 0x49, 0x6e, + 0x66, 0x6f, 0x10, 0xaf, 0x07, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, + 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xb0, + 0x07, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x64, 0x6d, + 0x69, 0x6e, 0x69, 0x73, 0x74, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x6c, 0x79, 0x43, 0x6f, 0x6e, + 0x66, 0x69, 0x67, 0x75, 0x72, 0x65, 0x64, 0x10, 0xb1, 0x07, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x42, 0x61, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x10, + 0xb2, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4c, 0x6f, + 0x6f, 0x70, 0x62, 0x61, 0x63, 0x6b, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, + 0x10, 0xb3, 0x07, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x53, + 0x6d, 0x61, 0x6c, 0x6c, 0x65, 0x72, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x10, 0xb4, 0x07, 0x12, 0x16, + 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x51, 0x75, 0x65, 0x75, 0x65, 0x46, + 0x75, 0x6c, 0x6c, 0x10, 0xb5, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, + 0x4c, 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x44, 0x69, 0x73, 0x61, 0x62, + 0x6c, 0x65, 0x64, 0x10, 0xb6, 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, + 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x10, 0xb7, 0x07, + 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, + 0x54, 0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, + 0xb8, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, + 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, + 0x6d, 0x10, 0xb9, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, + 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xba, + 0x07, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, + 0x70, 0x4e, 0x65, 0x69, 0x67, 0x68, 0x62, 0x6f, 0x72, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x76, 0x65, + 0x72, 0x79, 0x4c, 0x6f, 0x6f, 0x70, 0x62, 0x61, 0x63, 0x6b, 0x10, 0xbb, 0x07, 0x12, 0x1c, 0x0a, + 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x55, 0x6e, 0x6b, + 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x10, 0xbc, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x54, 0x72, 0x75, 0x6e, 0x63, + 0x61, 0x74, 0x65, 0x64, 0x49, 0x70, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xbd, 0x07, 0x12, + 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4f, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x70, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x10, 0xbe, 0x07, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, + 0x63, 0x6d, 0x70, 0x4e, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x10, 0xbf, 0x07, 0x12, + 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x54, 0x6f, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x10, 0xc0, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, + 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x10, 0xc1, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, + 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x52, 0x61, 0x74, 0x65, + 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0xc2, 0x07, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x50, 0x61, 0x74, 0x68, 0x52, 0x61, 0x74, 0x65, + 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0xc3, 0x07, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x10, + 0xc4, 0x07, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, + 0x6d, 0x70, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xc5, 0x07, 0x12, 0x1f, 0x0a, 0x1a, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x42, 0x75, 0x66, 0x66, + 0x65, 0x72, 0x54, 0x6f, 0x6f, 0x53, 0x6d, 0x61, 0x6c, 0x6c, 0x10, 0xc6, 0x07, 0x12, 0x23, 0x0a, + 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x41, 0x6e, 0x63, + 0x69, 0x6c, 0x6c, 0x61, 0x72, 0x79, 0x44, 0x61, 0x74, 0x61, 0x51, 0x75, 0x65, 0x72, 0x79, 0x10, + 0xc7, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, + 0x6d, 0x70, 0x49, 0x6e, 0x63, 0x6f, 0x72, 0x72, 0x65, 0x63, 0x74, 0x48, 0x6f, 0x70, 0x4c, 0x69, + 0x6d, 0x69, 0x74, 0x10, 0xc8, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, + 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x43, 0x6f, 0x64, + 0x65, 0x10, 0xc9, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, + 0x49, 0x63, 0x6d, 0x70, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x74, 0x4c, 0x69, 0x6e, + 0x6b, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0xca, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x54, 0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, + 0x65, 0x64, 0x4e, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xcb, 0x07, 0x12, 0x2b, 0x0a, + 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, + 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4c, + 0x69, 0x6e, 0x6b, 0x41, 0x64, 0x64, 0x72, 0x10, 0xcc, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x4d, 0x74, 0x75, 0x10, 0xcd, 0x07, 0x12, 0x2e, 0x0a, 0x29, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x49, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xce, 0x07, 0x12, 0x2d, 0x0a, 0x28, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xcf, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x52, 0x64, 0x6e, 0x73, 0x73, 0x10, 0xd0, 0x07, 0x12, + 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, + 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x4f, 0x70, 0x74, 0x44, 0x6e, 0x73, 0x73, 0x6c, + 0x10, 0xd1, 0x07, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, + 0x63, 0x6d, 0x70, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x50, 0x61, 0x72, 0x73, 0x69, 0x6e, 0x67, + 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xd2, 0x07, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x65, 0x64, 0x10, 0xd3, 0x07, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x52, 0x6f, + 0x75, 0x74, 0x65, 0x72, 0x41, 0x64, 0x76, 0x65, 0x72, 0x74, 0x69, 0x73, 0x65, 0x6d, 0x65, 0x6e, + 0x74, 0x10, 0xd4, 0x07, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, + 0x49, 0x63, 0x6d, 0x70, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x46, 0x72, 0x6f, 0x6d, 0x44, 0x69, + 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x74, 0x4c, 0x69, 0x6e, 0x6b, 0x10, 0xd5, 0x07, 0x12, 0x33, + 0x0a, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, + 0x76, 0x61, 0x6c, 0x69, 0x64, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x44, 0x65, 0x73, + 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4f, 0x72, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, + 0x10, 0xd6, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, + 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4e, 0x64, 0x54, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x10, 0xd7, 0x07, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, + 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4e, 0x61, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x73, 0x74, + 0x41, 0x6e, 0x64, 0x53, 0x6f, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x65, 0x64, 0x10, 0xd8, 0x07, 0x12, + 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4e, + 0x64, 0x4c, 0x69, 0x6e, 0x6b, 0x4c, 0x61, 0x79, 0x65, 0x72, 0x41, 0x64, 0x64, 0x72, 0x65, 0x73, + 0x73, 0x49, 0x73, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0xd9, 0x07, 0x12, 0x25, 0x0a, 0x20, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x44, 0x75, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x74, 0x65, 0x45, 0x63, 0x68, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, + 0xda, 0x07, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, + 0x6d, 0x70, 0x4e, 0x6f, 0x74, 0x41, 0x50, 0x6f, 0x74, 0x65, 0x6e, 0x74, 0x69, 0x61, 0x6c, 0x52, + 0x6f, 0x75, 0x74, 0x65, 0x72, 0x10, 0xdb, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4d, + 0x6c, 0x64, 0x51, 0x75, 0x65, 0x72, 0x79, 0x10, 0xdc, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x4d, 0x6c, 0x64, 0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x10, 0xdd, 0x07, 0x12, 0x28, 0x0a, + 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4c, 0x6f, 0x63, + 0x61, 0x6c, 0x6c, 0x79, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x64, 0x4d, 0x6c, 0x64, 0x52, 0x65, + 0x70, 0x6f, 0x72, 0x74, 0x10, 0xde, 0x07, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x4e, 0x6f, 0x74, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, + 0x79, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x64, 0x10, 0xdf, 0x07, 0x12, 0x1d, 0x0a, 0x18, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, + 0x69, 0x64, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x10, 0xe0, 0x07, 0x12, 0x1d, 0x0a, 0x18, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, + 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x10, 0xe1, 0x07, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x44, 0x6c, 0x53, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x49, 0x73, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0xe2, 0x07, 0x12, 0x22, 0x0a, 0x1d, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x41, 0x72, 0x70, 0x4e, 0x6f, 0x74, 0x4c, 0x6f, 0x63, + 0x61, 0x6c, 0x6c, 0x79, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x64, 0x10, 0xe3, 0x07, 0x12, + 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x4e, 0x6c, 0x43, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, 0x63, 0x61, 0x72, 0x64, 0x10, 0xe4, 0x07, 0x12, 0x2b, 0x0a, + 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x70, 0x73, 0x6e, 0x70, 0x69, 0x55, + 0x72, 0x6f, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x69, 0x7a, 0x65, 0x45, 0x78, 0x63, + 0x65, 0x65, 0x64, 0x73, 0x4d, 0x74, 0x75, 0x10, 0xe5, 0x07, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, 0x70, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x65, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x10, 0xe6, 0x07, 0x12, 0x24, 0x0a, + 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x46, 0x69, 0x72, 0x73, 0x74, 0x46, 0x72, + 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x65, + 0x10, 0xe7, 0x07, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x53, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x56, 0x69, 0x6f, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xe8, + 0x07, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x49, 0x63, 0x6d, + 0x70, 0x4a, 0x75, 0x6d, 0x62, 0x6f, 0x67, 0x72, 0x61, 0x6d, 0x10, 0xe9, 0x07, 0x12, 0x19, 0x0a, + 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x4c, 0x5f, 0x53, 0x77, 0x55, 0x73, 0x6f, 0x46, 0x61, + 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xea, 0x07, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x55, 0x6e, 0x73, 0x70, + 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x10, 0xb0, 0x09, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x4d, 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x73, 0x74, 0x10, 0xb1, 0x09, 0x12, + 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0xb2, 0x09, 0x12, 0x1e, 0x0a, + 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x43, 0x68, 0x65, 0x63, 0x6b, + 0x73, 0x75, 0x6d, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0xb3, 0x09, 0x12, 0x1f, 0x0a, + 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x45, 0x6e, 0x64, 0x70, 0x6f, + 0x69, 0x6e, 0x74, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xb4, 0x09, 0x12, 0x1c, + 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x43, 0x6f, 0x6e, 0x6e, + 0x65, 0x63, 0x74, 0x65, 0x64, 0x50, 0x61, 0x74, 0x68, 0x10, 0xb5, 0x09, 0x12, 0x1b, 0x0a, 0x16, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, + 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x10, 0xb6, 0x09, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x49, 0x6e, + 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xb7, 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x41, 0x63, 0x6b, 0x49, 0x6e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x10, 0xb8, 0x09, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, + 0x4e, 0x45, 0x54, 0x5f, 0x45, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x10, + 0xb9, 0x09, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, + 0x52, 0x73, 0x74, 0x10, 0xba, 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, + 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x79, 0x6e, 0x52, 0x63, 0x76, 0x64, 0x53, 0x79, 0x6e, 0x10, 0xbb, + 0x09, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, + 0x69, 0x6d, 0x75, 0x6c, 0x74, 0x61, 0x6e, 0x65, 0x6f, 0x75, 0x73, 0x43, 0x6f, 0x6e, 0x6e, 0x65, + 0x63, 0x74, 0x10, 0xbc, 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, + 0x45, 0x54, 0x5f, 0x50, 0x61, 0x77, 0x73, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xbd, 0x09, + 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x4c, 0x61, + 0x6e, 0x64, 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x10, 0xbe, 0x09, 0x12, 0x1a, 0x0a, 0x15, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x4d, 0x69, 0x73, 0x73, 0x65, 0x64, 0x52, + 0x65, 0x73, 0x65, 0x74, 0x10, 0xbf, 0x09, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x4f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, + 0x6f, 0x77, 0x10, 0xc0, 0x09, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, + 0x45, 0x54, 0x5f, 0x44, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x65, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x10, 0xc1, 0x09, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, + 0x4e, 0x45, 0x54, 0x5f, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, + 0x10, 0xc2, 0x09, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, + 0x5f, 0x54, 0x63, 0x62, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x64, 0x10, 0xc3, 0x09, 0x12, 0x17, + 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x46, 0x69, 0x6e, 0x57, + 0x61, 0x69, 0x74, 0x32, 0x10, 0xc4, 0x09, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x52, 0x65, 0x61, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x79, 0x43, + 0x6f, 0x6e, 0x66, 0x6c, 0x69, 0x63, 0x74, 0x10, 0xc5, 0x09, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x46, 0x69, 0x6e, 0x52, 0x65, 0x63, 0x65, 0x69, + 0x76, 0x65, 0x64, 0x10, 0xc6, 0x09, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, + 0x4e, 0x45, 0x54, 0x5f, 0x4c, 0x69, 0x73, 0x74, 0x65, 0x6e, 0x65, 0x72, 0x49, 0x6e, 0x76, 0x61, + 0x6c, 0x69, 0x64, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x10, 0xc7, 0x09, 0x12, 0x1f, 0x0a, 0x1a, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, 0x63, 0x62, 0x4e, 0x6f, 0x74, 0x49, + 0x6e, 0x54, 0x63, 0x62, 0x54, 0x61, 0x62, 0x6c, 0x65, 0x10, 0xc8, 0x09, 0x12, 0x32, 0x0a, 0x2d, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, 0x69, 0x6d, 0x65, 0x57, 0x61, + 0x69, 0x74, 0x54, 0x63, 0x62, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x52, 0x73, 0x74, + 0x4f, 0x75, 0x74, 0x73, 0x69, 0x64, 0x65, 0x57, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x10, 0xc9, 0x09, + 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, 0x69, + 0x6d, 0x65, 0x57, 0x61, 0x69, 0x74, 0x54, 0x63, 0x62, 0x53, 0x79, 0x6e, 0x41, 0x6e, 0x64, 0x4f, + 0x74, 0x68, 0x65, 0x72, 0x46, 0x6c, 0x61, 0x67, 0x73, 0x10, 0xca, 0x09, 0x12, 0x1a, 0x0a, 0x15, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x54, 0x69, 0x6d, 0x65, 0x57, 0x61, + 0x69, 0x74, 0x54, 0x63, 0x62, 0x10, 0xcb, 0x09, 0x12, 0x2e, 0x0a, 0x29, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x53, 0x79, 0x6e, 0x41, 0x63, 0x6b, 0x57, 0x69, 0x74, 0x68, + 0x46, 0x61, 0x73, 0x74, 0x6f, 0x70, 0x65, 0x6e, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xcc, 0x09, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x50, 0x61, 0x75, 0x73, 0x65, 0x41, 0x63, 0x63, 0x65, 0x70, + 0x74, 0x10, 0xcd, 0x09, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, + 0x54, 0x5f, 0x53, 0x79, 0x6e, 0x41, 0x74, 0x74, 0x61, 0x63, 0x6b, 0x10, 0xce, 0x09, 0x12, 0x1f, + 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x41, 0x63, 0x63, 0x65, + 0x70, 0x74, 0x49, 0x6e, 0x73, 0x70, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xcf, 0x09, 0x12, + 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x4e, 0x45, 0x54, 0x5f, 0x41, 0x63, 0x63, + 0x65, 0x70, 0x74, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xd0, + 0x09, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, + 0x5f, 0x50, 0x61, 0x72, 0x73, 0x69, 0x6e, 0x67, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, + 0x95, 0x0a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, + 0x78, 0x5f, 0x46, 0x69, 0x72, 0x73, 0x74, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4d, + 0x69, 0x73, 0x73, 0x10, 0x96, 0x0a, 0x12, 0x32, 0x0a, 0x2d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, + 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x49, 0x43, 0x4d, 0x50, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x50, + 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x97, 0x0a, 0x12, 0x2e, 0x0a, 0x29, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x49, 0x43, 0x4d, 0x50, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x4e, 0x6f, + 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0x98, 0x0a, 0x12, 0x34, 0x0a, 0x2f, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, + 0x61, 0x6c, 0x48, 0x61, 0x69, 0x72, 0x70, 0x69, 0x6e, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, 0x70, + 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x99, 0x0a, + 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, + 0x4e, 0x6f, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x61, 0x74, 0x69, 0x63, + 0x4d, 0x61, 0x70, 0x70, 0x69, 0x6e, 0x67, 0x10, 0x9a, 0x0a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, + 0x70, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, + 0x65, 0x10, 0x9b, 0x0a, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, + 0x4d, 0x75, 0x78, 0x5f, 0x43, 0x6c, 0x6f, 0x6e, 0x69, 0x6e, 0x67, 0x46, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x10, 0x9c, 0x0a, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, + 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0x9d, 0x0a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x48, 0x6f, 0x70, 0x4c, 0x69, 0x6d, + 0x69, 0x74, 0x45, 0x78, 0x63, 0x65, 0x65, 0x64, 0x65, 0x64, 0x10, 0x9e, 0x0a, 0x12, 0x24, 0x0a, + 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x50, 0x61, 0x63, + 0x6b, 0x65, 0x74, 0x42, 0x69, 0x67, 0x67, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e, 0x4d, 0x54, 0x55, + 0x10, 0x9f, 0x0a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, + 0x75, 0x78, 0x5f, 0x55, 0x6e, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x52, 0x6f, 0x75, + 0x74, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, + 0xa0, 0x0a, 0x12, 0x18, 0x0a, 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, + 0x78, 0x5f, 0x4e, 0x6f, 0x52, 0x6f, 0x75, 0x74, 0x65, 0x10, 0xa1, 0x0a, 0x12, 0x27, 0x0a, 0x22, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x53, 0x65, 0x73, 0x73, + 0x69, 0x6f, 0x6e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x10, 0xa2, 0x0a, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, + 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, 0x70, 0x4e, 0x6f, 0x74, 0x4f, + 0x76, 0x65, 0x72, 0x45, 0x78, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x65, 0x72, + 0x66, 0x61, 0x63, 0x65, 0x10, 0xa3, 0x0a, 0x12, 0x38, 0x0a, 0x33, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, 0x70, 0x45, 0x78, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x66, 0x61, 0x63, 0x65, 0x4d, + 0x69, 0x73, 0x73, 0x4e, 0x41, 0x54, 0x49, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x10, 0xa4, + 0x0a, 0x12, 0x2f, 0x0a, 0x2a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, + 0x5f, 0x4e, 0x41, 0x54, 0x49, 0x74, 0x73, 0x65, 0x6c, 0x66, 0x43, 0x61, 0x6e, 0x74, 0x42, 0x65, + 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x4e, 0x65, 0x78, 0x74, 0x68, 0x6f, 0x70, 0x10, + 0xa5, 0x0a, 0x12, 0x36, 0x0a, 0x31, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, + 0x78, 0x5f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x52, 0x6f, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x49, 0x6e, 0x49, 0x74, 0x73, 0x41, 0x72, 0x72, 0x69, 0x76, 0x61, 0x6c, 0x43, 0x6f, 0x6d, 0x70, + 0x61, 0x72, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x10, 0xa6, 0x0a, 0x12, 0x34, 0x0a, 0x2f, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 0x6f, + 0x6c, 0x4e, 0x6f, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x10, 0xa7, 0x0a, + 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x73, 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x65, 0x64, + 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x6c, 0x79, 0x10, 0xa8, 0x0a, 0x12, 0x3a, 0x0a, 0x35, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x44, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x50, 0x61, 0x6e, 0x64, + 0x50, 0x6f, 0x72, 0x74, 0x4e, 0x6f, 0x74, 0x53, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x54, 0x6f, + 0x4e, 0x41, 0x54, 0x10, 0xa9, 0x0a, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, + 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4d, 0x75, 0x78, 0x52, 0x65, 0x6a, 0x65, 0x63, 0x74, 0x10, + 0xaa, 0x0a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, + 0x78, 0x5f, 0x44, 0x69, 0x70, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, 0x61, 0x69, 0x6c, 0x75, + 0x72, 0x65, 0x10, 0xab, 0x0a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, + 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x4d, 0x75, 0x78, 0x45, 0x6e, 0x63, 0x61, 0x70, 0x73, 0x75, 0x6c, + 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xac, 0x0a, 0x12, + 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x49, + 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x44, 0x69, 0x61, 0x67, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, + 0x45, 0x6e, 0x63, 0x61, 0x70, 0x54, 0x79, 0x70, 0x65, 0x10, 0xad, 0x0a, 0x12, 0x25, 0x0a, 0x20, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, 0x75, 0x78, 0x5f, 0x44, 0x69, 0x61, 0x67, + 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x49, 0x73, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, + 0x10, 0xae, 0x0a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x53, 0x6c, 0x62, 0x4d, + 0x75, 0x78, 0x5f, 0x55, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x54, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, + 0x65, 0x52, 0x65, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x10, 0xaf, 0x0a, 0x12, 0x16, 0x0a, 0x11, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x42, 0x61, 0x64, 0x53, 0x70, + 0x69, 0x10, 0xf9, 0x0a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, + 0x65, 0x63, 0x5f, 0x53, 0x41, 0x4c, 0x69, 0x66, 0x65, 0x74, 0x69, 0x6d, 0x65, 0x45, 0x78, 0x70, + 0x69, 0x72, 0x65, 0x64, 0x10, 0xfa, 0x0a, 0x12, 0x17, 0x0a, 0x12, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x57, 0x72, 0x6f, 0x6e, 0x67, 0x53, 0x41, 0x10, 0xfb, 0x0a, + 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x52, + 0x65, 0x70, 0x6c, 0x61, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x46, 0x61, 0x69, 0x6c, 0x65, 0x64, + 0x10, 0xfc, 0x0a, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, + 0x63, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x10, + 0xfd, 0x0a, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, + 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x67, 0x72, 0x69, 0x74, 0x79, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x46, + 0x61, 0x69, 0x6c, 0x65, 0x64, 0x10, 0xfe, 0x0a, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x43, 0x6c, 0x65, 0x61, 0x72, 0x54, 0x65, 0x78, 0x74, + 0x44, 0x72, 0x6f, 0x70, 0x10, 0xff, 0x0a, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x41, 0x75, 0x74, 0x68, 0x46, 0x69, 0x72, 0x65, 0x77, 0x61, + 0x6c, 0x6c, 0x44, 0x72, 0x6f, 0x70, 0x10, 0x80, 0x0b, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x54, 0x68, 0x72, 0x6f, 0x74, 0x74, 0x6c, 0x65, + 0x44, 0x72, 0x6f, 0x70, 0x10, 0x81, 0x0b, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x10, 0x82, 0x0b, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, + 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x4d, + 0x75, 0x6c, 0x74, 0x69, 0x63, 0x61, 0x73, 0x74, 0x10, 0x83, 0x0b, 0x12, 0x22, 0x0a, 0x1d, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x49, + 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x10, 0x84, 0x0b, 0x12, + 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, + 0x73, 0x70, 0x5f, 0x53, 0x74, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x46, 0x61, + 0x69, 0x6c, 0x65, 0x64, 0x10, 0x85, 0x0b, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x4d, 0x61, 0x78, 0x45, 0x6e, + 0x74, 0x72, 0x69, 0x65, 0x73, 0x10, 0x86, 0x0b, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, 0x73, 0x70, 0x5f, 0x4b, 0x65, 0x79, 0x6d, + 0x6f, 0x64, 0x4e, 0x6f, 0x74, 0x41, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x87, 0x0b, 0x12, + 0x2c, 0x0a, 0x27, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x44, 0x6f, + 0x73, 0x70, 0x5f, 0x4d, 0x61, 0x78, 0x50, 0x65, 0x72, 0x49, 0x70, 0x52, 0x61, 0x74, 0x65, 0x4c, + 0x69, 0x6d, 0x69, 0x74, 0x51, 0x75, 0x65, 0x75, 0x65, 0x73, 0x10, 0x88, 0x0b, 0x12, 0x18, 0x0a, + 0x13, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x4e, 0x6f, 0x4d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x10, 0x89, 0x0b, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x49, 0x70, 0x73, 0x65, 0x63, 0x5f, 0x55, 0x6e, 0x73, 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, + 0x75, 0x6c, 0x10, 0x8a, 0x0b, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, + 0x74, 0x43, 0x78, 0x5f, 0x4e, 0x65, 0x74, 0x50, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x4c, 0x61, 0x79, + 0x6f, 0x75, 0x74, 0x50, 0x61, 0x72, 0x73, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, + 0xdd, 0x0b, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, + 0x5f, 0x53, 0x6f, 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x73, 0x75, + 0x6d, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xde, 0x0b, 0x12, 0x1c, 0x0a, 0x17, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x4e, 0x69, 0x63, 0x51, 0x75, 0x65, + 0x75, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x10, 0xdf, 0x0b, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x4e, + 0x65, 0x74, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xe0, + 0x0b, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, + 0x4c, 0x53, 0x4f, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xe1, 0x0b, 0x12, 0x1a, 0x0a, + 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x55, 0x53, 0x4f, 0x46, + 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xe2, 0x0b, 0x12, 0x32, 0x0a, 0x2d, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x4e, 0x65, 0x74, 0x43, 0x78, 0x5f, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x42, 0x6f, + 0x75, 0x6e, 0x63, 0x65, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x41, 0x6e, 0x64, 0x50, 0x61, + 0x63, 0x6b, 0x65, 0x74, 0x49, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x10, 0xe3, 0x0b, 0x12, 0x14, 0x0a, + 0x0f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x42, 0x65, 0x67, 0x69, 0x6e, + 0x10, 0xb8, 0x17, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, + 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x5f, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x10, 0xb9, + 0x17, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, + 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xba, 0x17, 0x12, 0x1a, 0x0a, 0x15, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x56, 0x65, + 0x72, 0x62, 0x10, 0xbb, 0x17, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x55, 0x72, 0x6c, 0x10, 0xbc, 0x17, + 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xbd, 0x17, 0x12, 0x1a, + 0x0a, 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x48, 0x6f, 0x73, 0x74, 0x10, 0xbe, 0x17, 0x12, 0x19, 0x0a, 0x14, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4e, + 0x75, 0x6d, 0x10, 0xbf, 0x17, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4c, + 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc0, 0x17, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc1, 0x17, 0x12, 0x22, 0x0a, + 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x10, 0xc2, + 0x17, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, + 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64, 0x64, 0x65, 0x6e, 0x55, + 0x72, 0x6c, 0x10, 0xc3, 0x17, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, + 0x6e, 0x64, 0x10, 0xc4, 0x17, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, + 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc5, 0x17, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x50, + 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x65, + 0x64, 0x10, 0xc6, 0x17, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, + 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x54, + 0x6f, 0x6f, 0x4c, 0x61, 0x72, 0x67, 0x65, 0x10, 0xc7, 0x17, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x55, + 0x72, 0x6c, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xc8, 0x17, 0x12, 0x29, 0x0a, 0x24, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x4e, 0x6f, 0x74, 0x53, 0x61, 0x74, 0x69, 0x73, 0x66, 0x69, 0x61, + 0x62, 0x6c, 0x65, 0x10, 0xc9, 0x17, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, + 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x69, 0x73, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x65, 0x64, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0xca, 0x17, + 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x53, 0x65, 0x72, + 0x76, 0x65, 0x72, 0x10, 0xcb, 0x17, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, + 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4e, 0x6f, 0x74, 0x49, 0x6d, + 0x70, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x65, 0x64, 0x10, 0xcc, 0x17, 0x12, 0x21, 0x0a, 0x1c, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, + 0x72, 0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x10, 0xcd, 0x17, 0x12, + 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, + 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x69, + 0x6d, 0x69, 0x74, 0x10, 0xce, 0x17, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, + 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x61, 0x70, 0x69, 0x64, + 0x46, 0x61, 0x69, 0x6c, 0x50, 0x72, 0x6f, 0x74, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0xcf, + 0x17, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, + 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x51, 0x75, 0x65, + 0x75, 0x65, 0x46, 0x75, 0x6c, 0x6c, 0x10, 0xd0, 0x17, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x44, 0x69, + 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x79, 0x41, 0x64, 0x6d, 0x69, 0x6e, 0x10, 0xd1, 0x17, + 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, + 0x45, 0x72, 0x72, 0x6f, 0x72, 0x44, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x42, 0x79, 0x41, + 0x70, 0x70, 0x10, 0xd2, 0x17, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4a, 0x6f, 0x62, 0x4f, 0x62, 0x6a, + 0x65, 0x63, 0x74, 0x46, 0x69, 0x72, 0x65, 0x64, 0x10, 0xd3, 0x17, 0x12, 0x21, 0x0a, 0x1c, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, + 0x41, 0x70, 0x70, 0x50, 0x6f, 0x6f, 0x6c, 0x42, 0x75, 0x73, 0x79, 0x10, 0xd4, 0x17, 0x12, 0x1d, + 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, + 0x72, 0x6f, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0xd5, 0x17, 0x12, 0x1a, 0x0a, + 0x15, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x6c, 0x45, 0x72, 0x72, + 0x6f, 0x72, 0x5f, 0x45, 0x6e, 0x64, 0x10, 0xd6, 0x17, 0x12, 0x1e, 0x0a, 0x19, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, + 0x74, 0x42, 0x65, 0x67, 0x69, 0x6e, 0x10, 0xc8, 0x1a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, + 0x74, 0x55, 0x73, 0x65, 0x72, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x10, 0xc9, 0x1a, 0x12, 0x23, 0x0a, + 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, + 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, + 0xca, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x52, 0x65, 0x73, 0x65, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x10, 0xcb, 0x1a, 0x12, 0x27, + 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, + 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4e, 0x6f, 0x74, 0x46, + 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xcc, 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x65, 0x4d, 0x69, 0x73, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x10, 0xcd, 0x1a, + 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, + 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, 0x4e, 0x6f, + 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xce, 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, + 0x74, 0x44, 0x61, 0x74, 0x61, 0x41, 0x66, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x64, 0x10, 0xcf, 0x1a, + 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, + 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x61, 0x74, 0x68, 0x4e, 0x6f, 0x74, 0x46, + 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xd0, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x48, + 0x61, 0x6c, 0x66, 0x43, 0x6c, 0x6f, 0x73, 0x65, 0x64, 0x4c, 0x6f, 0x63, 0x61, 0x6c, 0x10, 0xd1, + 0x1a, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, + 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x70, 0x61, + 0x74, 0x69, 0x62, 0x6c, 0x65, 0x41, 0x75, 0x74, 0x68, 0x10, 0xd2, 0x1a, 0x12, 0x24, 0x0a, 0x1f, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, + 0x61, 0x75, 0x6c, 0x74, 0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x33, 0x10, + 0xd3, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, + 0x43, 0x65, 0x72, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x65, 0x64, 0x10, 0xd4, 0x1a, 0x12, 0x28, + 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, + 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, + 0x45, 0x6d, 0x70, 0x74, 0x79, 0x10, 0xd5, 0x1a, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, + 0x49, 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x53, 0x65, 0x6e, 0x64, 0x10, 0xd6, 0x1a, 0x12, 0x28, + 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, + 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x75, 0x73, 0x68, 0x55, 0x70, 0x70, 0x65, 0x72, 0x41, + 0x74, 0x74, 0x61, 0x63, 0x68, 0x10, 0xd7, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, + 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x55, 0x70, 0x70, 0x65, 0x72, 0x41, 0x74, 0x74, 0x61, 0x63, + 0x68, 0x10, 0xd8, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, + 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4c, 0x69, 0x6d, 0x69, 0x74, 0x10, 0xd9, 0x1a, + 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, + 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x74, + 0x79, 0x4e, 0x6f, 0x74, 0x46, 0x6f, 0x75, 0x6e, 0x64, 0x10, 0xda, 0x1a, 0x12, 0x27, 0x0a, 0x22, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, + 0x61, 0x75, 0x6c, 0x74, 0x55, 0x6e, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x54, 0x61, + 0x69, 0x6c, 0x10, 0xdb, 0x1a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x72, 0x75, + 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x10, 0xdc, 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, + 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x6f, 0x6c, 0x64, 0x10, 0xdd, 0x1a, + 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, + 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x43, + 0x68, 0x75, 0x6e, 0x6b, 0x65, 0x64, 0x10, 0xde, 0x1a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, + 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, + 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0xdf, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x65, 0x64, 0x10, + 0xe0, 0x1a, 0x12, 0x2e, 0x0a, 0x29, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, + 0xe1, 0x1a, 0x12, 0x31, 0x0a, 0x2c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, + 0x6e, 0x67, 0x10, 0xe2, 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4c, 0x69, 0x6e, 0x65, 0x10, 0xe3, 0x1a, 0x12, 0x27, 0x0a, 0x22, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, + 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x10, 0xe4, 0x1a, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, + 0x6e, 0x65, 0x63, 0x74, 0x10, 0xe5, 0x1a, 0x12, 0x23, 0x0a, 0x1e, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, + 0x68, 0x75, 0x6e, 0x6b, 0x53, 0x74, 0x61, 0x72, 0x74, 0x10, 0xe6, 0x1a, 0x12, 0x24, 0x0a, 0x1f, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, + 0x61, 0x75, 0x6c, 0x74, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, + 0xe7, 0x1a, 0x12, 0x22, 0x0a, 0x1d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x53, + 0x74, 0x6f, 0x70, 0x10, 0xe8, 0x1a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, + 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x73, 0x41, 0x66, 0x74, 0x65, 0x72, 0x54, 0x72, 0x61, 0x69, 0x6c, 0x65, + 0x72, 0x73, 0x10, 0xe9, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x73, 0x41, 0x66, 0x74, 0x65, 0x72, 0x45, 0x6e, 0x64, 0x10, 0xea, 0x1a, 0x12, + 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, + 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x45, 0x6e, 0x64, 0x6c, 0x65, 0x73, 0x73, 0x54, 0x72, + 0x61, 0x69, 0x6c, 0x65, 0x72, 0x10, 0xeb, 0x1a, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, + 0x10, 0xec, 0x1a, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, + 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x75, 0x6c, 0x74, 0x69, + 0x70, 0x6c, 0x65, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x6f, 0x64, 0x69, 0x6e, + 0x67, 0x73, 0x10, 0xed, 0x1a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, + 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x75, 0x73, + 0x68, 0x42, 0x6f, 0x64, 0x79, 0x10, 0xee, 0x1a, 0x12, 0x28, 0x0a, 0x23, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, + 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x41, 0x62, 0x61, 0x6e, 0x64, 0x6f, 0x6e, 0x65, 0x64, 0x10, + 0xef, 0x1a, 0x12, 0x26, 0x0a, 0x21, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4d, 0x61, 0x6c, 0x66, 0x6f, 0x72, + 0x6d, 0x65, 0x64, 0x48, 0x6f, 0x73, 0x74, 0x10, 0xf0, 0x1a, 0x12, 0x2e, 0x0a, 0x29, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, + 0x6c, 0x74, 0x44, 0x65, 0x63, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x4f, + 0x76, 0x65, 0x72, 0x66, 0x6c, 0x6f, 0x77, 0x10, 0xf1, 0x1a, 0x12, 0x2a, 0x0a, 0x25, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, + 0x6c, 0x74, 0x49, 0x6c, 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x4e, + 0x61, 0x6d, 0x65, 0x10, 0xf2, 0x1a, 0x12, 0x2b, 0x0a, 0x26, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, + 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x49, 0x6c, + 0x6c, 0x65, 0x67, 0x61, 0x6c, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x10, 0xf3, 0x1a, 0x12, 0x2d, 0x0a, 0x28, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, + 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x48, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, + 0xf4, 0x1a, 0x12, 0x2c, 0x0a, 0x27, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x4d, 0x61, 0x6c, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x10, 0xf5, 0x1a, + 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, + 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6f, 0x6b, 0x69, 0x65, 0x52, 0x65, + 0x61, 0x73, 0x73, 0x65, 0x6d, 0x62, 0x6c, 0x79, 0x10, 0xf6, 0x1a, 0x12, 0x25, 0x0a, 0x20, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, + 0x75, 0x6c, 0x74, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, + 0xf7, 0x1a, 0x12, 0x29, 0x0a, 0x24, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x65, + 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0xf8, 0x1a, 0x12, 0x27, 0x0a, + 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, + 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x61, 0x74, 0x68, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, + 0x77, 0x65, 0x64, 0x10, 0xf9, 0x1a, 0x12, 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, + 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x75, + 0x73, 0x68, 0x48, 0x6f, 0x73, 0x74, 0x10, 0xfa, 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, + 0x74, 0x47, 0x6f, 0x61, 0x77, 0x61, 0x79, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x64, 0x10, + 0xfb, 0x1a, 0x12, 0x27, 0x0a, 0x22, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x41, 0x62, 0x6f, 0x72, 0x74, 0x4c, + 0x65, 0x67, 0x61, 0x63, 0x79, 0x41, 0x70, 0x70, 0x10, 0xfc, 0x1a, 0x12, 0x30, 0x0a, 0x2b, 0x44, + 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, + 0x75, 0x6c, 0x74, 0x55, 0x70, 0x67, 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0xfd, 0x1a, 0x12, 0x2e, 0x0a, + 0x29, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, + 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x55, 0x70, 0x67, + 0x72, 0x61, 0x64, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0xfe, 0x1a, 0x12, 0x32, 0x0a, + 0x2d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, + 0x46, 0x61, 0x75, 0x6c, 0x74, 0x4b, 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0xff, + 0x1a, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, + 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x4b, 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, + 0x10, 0x80, 0x1b, 0x12, 0x32, 0x0a, 0x2d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, + 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x50, 0x72, 0x6f, 0x78, 0x79, + 0x43, 0x6f, 0x6e, 0x6e, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, + 0x6f, 0x77, 0x65, 0x64, 0x10, 0x81, 0x1b, 0x12, 0x30, 0x0a, 0x2b, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x50, 0x72, 0x6f, 0x78, 0x79, 0x43, 0x6f, 0x6e, 0x6e, + 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x10, 0x82, 0x1b, 0x12, 0x2c, 0x0a, 0x27, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, + 0x74, 0x43, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x47, 0x6f, 0x69, 0x6e, 0x67, + 0x41, 0x77, 0x61, 0x79, 0x10, 0x83, 0x1b, 0x12, 0x33, 0x0a, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x54, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x45, 0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x44, + 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x84, 0x1b, 0x12, 0x30, 0x0a, 0x2b, + 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, + 0x61, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x6e, 0x67, 0x74, + 0x68, 0x44, 0x69, 0x73, 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x85, 0x1b, 0x12, 0x2a, + 0x0a, 0x25, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, + 0x6f, 0x46, 0x61, 0x75, 0x6c, 0x74, 0x54, 0x72, 0x61, 0x69, 0x6c, 0x65, 0x72, 0x44, 0x69, 0x73, + 0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x10, 0x86, 0x1b, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x55, 0x78, 0x44, 0x75, 0x6f, 0x46, 0x61, 0x75, + 0x6c, 0x74, 0x45, 0x6e, 0x64, 0x10, 0x87, 0x1b, 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, + 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x52, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x53, 0x75, 0x70, + 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x10, 0x90, 0x1c, 0x12, 0x16, 0x0a, 0x11, 0x44, 0x72, + 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x10, + 0xd8, 0x1d, 0x12, 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, + 0x10, 0xd9, 0x1d, 0x12, 0x24, 0x0a, 0x1f, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, + 0x5f, 0x49, 0x6e, 0x73, 0x75, 0x66, 0x66, 0x69, 0x63, 0x69, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x10, 0xda, 0x1d, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, + 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x48, 0x61, + 0x6e, 0x64, 0x6c, 0x65, 0x10, 0xdb, 0x1d, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, + 0x48, 0x74, 0x74, 0x70, 0x5f, 0x4e, 0x6f, 0x74, 0x53, 0x75, 0x70, 0x70, 0x6f, 0x72, 0x74, 0x65, + 0x64, 0x10, 0xdc, 0x1d, 0x12, 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, + 0x70, 0x5f, 0x42, 0x61, 0x64, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x50, 0x61, 0x74, 0x68, + 0x10, 0xdd, 0x1d, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, + 0x5f, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x10, 0xde, + 0x1d, 0x12, 0x1c, 0x0a, 0x17, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x4e, + 0x6f, 0x53, 0x75, 0x63, 0x68, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x10, 0xdf, 0x1d, 0x12, + 0x1f, 0x0a, 0x1a, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x50, 0x72, 0x69, + 0x76, 0x69, 0x6c, 0x65, 0x67, 0x65, 0x4e, 0x6f, 0x74, 0x48, 0x65, 0x6c, 0x64, 0x10, 0xe0, 0x1d, + 0x12, 0x20, 0x0a, 0x1b, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x43, 0x61, + 0x6e, 0x6e, 0x6f, 0x74, 0x49, 0x6d, 0x70, 0x65, 0x72, 0x73, 0x6f, 0x6e, 0x61, 0x74, 0x65, 0x10, + 0xe1, 0x1d, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x4c, 0x6f, 0x67, 0x6f, 0x6e, 0x46, 0x61, 0x69, 0x6c, 0x75, 0x72, 0x65, 0x10, 0xe2, 0x1d, 0x12, + 0x21, 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x4e, 0x6f, 0x53, + 0x75, 0x63, 0x68, 0x4c, 0x6f, 0x67, 0x6f, 0x6e, 0x53, 0x65, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x10, + 0xe3, 0x1d, 0x12, 0x1b, 0x0a, 0x16, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, + 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x44, 0x65, 0x6e, 0x69, 0x65, 0x64, 0x10, 0xe4, 0x1d, 0x12, + 0x1d, 0x0a, 0x18, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x4e, 0x6f, 0x4c, + 0x6f, 0x67, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x73, 0x10, 0xe5, 0x1d, 0x12, 0x21, + 0x0a, 0x1c, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x54, 0x69, 0x6d, 0x65, + 0x44, 0x69, 0x66, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x41, 0x74, 0x44, 0x63, 0x10, 0xe6, + 0x1d, 0x12, 0x12, 0x0a, 0x0d, 0x44, 0x72, 0x6f, 0x70, 0x5f, 0x48, 0x74, 0x74, 0x70, 0x5f, 0x45, + 0x6e, 0x64, 0x10, 0xa0, 0x1f, 0x42, 0x27, 0x5a, 0x25, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x6f, 0x66, 0x74, 0x2f, 0x72, 0x65, + 0x74, 0x69, 0x6e, 0x61, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x75, 0x74, 0x69, 0x6c, 0x73, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_metadata_windows_proto_rawDescOnce sync.Once + file_metadata_windows_proto_rawDescData = file_metadata_windows_proto_rawDesc +) + +func file_metadata_windows_proto_rawDescGZIP() []byte { + file_metadata_windows_proto_rawDescOnce.Do(func() { + file_metadata_windows_proto_rawDescData = protoimpl.X.CompressGZIP(file_metadata_windows_proto_rawDescData) + }) + return file_metadata_windows_proto_rawDescData +} + +var file_metadata_windows_proto_enumTypes = make([]protoimpl.EnumInfo, 3) +var file_metadata_windows_proto_msgTypes = make([]protoimpl.MessageInfo, 10) +var file_metadata_windows_proto_goTypes = []interface{}{ + (VfpDirection)(0), // 0: utils.VfpDirection + (DNSType)(0), // 1: utils.DNSType + (DropReason)(0), // 2: utils.DropReason + (*RetinaMetadata)(nil), // 3: utils.RetinaMetadata + (*EndpointStats)(nil), // 4: utils.EndpointStats + (*VfpTcpConnectionStats)(nil), // 5: utils.VfpTcpConnectionStats + (*VfpTcpPacketStats)(nil), // 6: utils.VfpTcpPacketStats + (*VfpPacketDropStats)(nil), // 7: utils.VfpPacketDropStats + (*VfpTcpStats)(nil), // 8: utils.VfpTcpStats + (*VfpDirectedPortCounters)(nil), // 9: utils.VfpDirectedPortCounters + (*VfpPortStatsData)(nil), // 10: utils.VfpPortStatsData + (*HNSStatsMetadata)(nil), // 11: utils.HNSStatsMetadata + nil, // 12: utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry +} +var file_metadata_windows_proto_depIdxs = []int32{ + 1, // 0: utils.RetinaMetadata.dns_type:type_name -> utils.DNSType + 2, // 1: utils.RetinaMetadata.drop_reason:type_name -> utils.DropReason + 12, // 2: utils.RetinaMetadata.previously_observed_tcp_flags:type_name -> utils.RetinaMetadata.PreviouslyObservedTcpFlagsEntry + 5, // 3: utils.VfpTcpStats.ConnectionCounters:type_name -> utils.VfpTcpConnectionStats + 6, // 4: utils.VfpTcpStats.PacketCounters:type_name -> utils.VfpTcpPacketStats + 0, // 5: utils.VfpDirectedPortCounters.direction:type_name -> utils.VfpDirection + 8, // 6: utils.VfpDirectedPortCounters.TcpCounters:type_name -> utils.VfpTcpStats + 7, // 7: utils.VfpDirectedPortCounters.DropCounters:type_name -> utils.VfpPacketDropStats + 9, // 8: utils.VfpPortStatsData.In:type_name -> utils.VfpDirectedPortCounters + 9, // 9: utils.VfpPortStatsData.Out:type_name -> utils.VfpDirectedPortCounters + 4, // 10: utils.HNSStatsMetadata.EndpointStats:type_name -> utils.EndpointStats + 10, // 11: utils.HNSStatsMetadata.VfpPortStatsData:type_name -> utils.VfpPortStatsData + 12, // [12:12] is the sub-list for method output_type + 12, // [12:12] is the sub-list for method input_type + 12, // [12:12] is the sub-list for extension type_name + 12, // [12:12] is the sub-list for extension extendee + 0, // [0:12] is the sub-list for field type_name +} + +func init() { file_metadata_windows_proto_init() } +func file_metadata_windows_proto_init() { + if File_metadata_windows_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_metadata_windows_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*RetinaMetadata); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EndpointStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpTcpConnectionStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpTcpPacketStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpPacketDropStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpTcpStats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpDirectedPortCounters); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VfpPortStatsData); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_metadata_windows_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*HNSStatsMetadata); i { case 0: return &v.state case 1: @@ -2386,19 +3215,19 @@ func file_pkg_utils_metadata_windows_proto_init() { out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_pkg_utils_metadata_windows_proto_rawDesc, - NumEnums: 2, - NumMessages: 2, + RawDescriptor: file_metadata_windows_proto_rawDesc, + NumEnums: 3, + NumMessages: 10, NumExtensions: 0, NumServices: 0, }, - GoTypes: file_pkg_utils_metadata_windows_proto_goTypes, - DependencyIndexes: file_pkg_utils_metadata_windows_proto_depIdxs, - EnumInfos: file_pkg_utils_metadata_windows_proto_enumTypes, - MessageInfos: file_pkg_utils_metadata_windows_proto_msgTypes, + GoTypes: file_metadata_windows_proto_goTypes, + DependencyIndexes: file_metadata_windows_proto_depIdxs, + EnumInfos: file_metadata_windows_proto_enumTypes, + MessageInfos: file_metadata_windows_proto_msgTypes, }.Build() - File_pkg_utils_metadata_windows_proto = out.File - file_pkg_utils_metadata_windows_proto_rawDesc = nil - file_pkg_utils_metadata_windows_proto_goTypes = nil - file_pkg_utils_metadata_windows_proto_depIdxs = nil + File_metadata_windows_proto = out.File + file_metadata_windows_proto_rawDesc = nil + file_metadata_windows_proto_goTypes = nil + file_metadata_windows_proto_depIdxs = nil } diff --git a/pkg/utils/metadata_windows.proto b/pkg/utils/metadata_windows.proto index 2139f3721e..24cc7312f8 100644 --- a/pkg/utils/metadata_windows.proto +++ b/pkg/utils/metadata_windows.proto @@ -22,6 +22,65 @@ message RetinaMetadata { map previously_observed_tcp_flags = 8; } +// HNS stats for standalone +enum VfpDirection { + OUT = 0; + IN = 1; +} + +message EndpointStats { + uint64 BytesReceived = 1; + uint64 BytesSent = 2; + uint64 DroppedPacketsIncoming = 3; + uint64 DroppedPacketsOutgoing = 4; + string EndpointID = 5; + string InstanceID = 6; + uint64 PacketsReceived = 7; + uint64 PacketsSent = 8; +} + +message VfpTcpConnectionStats { + uint64 VerifiedCount = 1; + uint64 TimedOutCount = 2; + uint64 ResetCount = 3; + uint64 ResetSynCount = 4; + uint64 ClosedFinCount = 5; + uint64 TcpHalfOpenTimeoutsCount = 6; + uint64 TimeWaitExpiredCount = 7; +} + +message VfpTcpPacketStats { + uint64 SynPacketCount = 1; + uint64 SynAckPacketCount = 2; + uint64 FinPacketCount = 3; + uint64 RstPacketCount = 4; +} + +message VfpPacketDropStats { + uint64 AclDropPacketCount = 1; +} + +message VfpTcpStats { + VfpTcpConnectionStats ConnectionCounters = 1; + VfpTcpPacketStats PacketCounters = 2; +} + +message VfpDirectedPortCounters { + VfpDirection direction = 1; + VfpTcpStats TcpCounters = 2; + VfpPacketDropStats DropCounters = 3; +} + +message VfpPortStatsData { + VfpDirectedPortCounters In = 1; + VfpDirectedPortCounters Out = 2; +} + +message HNSStatsMetadata { + EndpointStats EndpointStats = 1; + VfpPortStatsData VfpPortStatsData = 2; +} + enum DNSType { UNKNOWN = 0; QUERY = 1; diff --git a/test/enricher/main_linux.go b/test/enricher/main_linux.go index acb700be85..3740ae1c37 100644 --- a/test/enricher/main_linux.go +++ b/test/enricher/main_linux.go @@ -26,7 +26,7 @@ func main() { ctx := context.Background() c := cache.New(pubsub.New()) - e := enricher.New(ctx, c) + e := enricher.New(ctx, c, false) e.Run() diff --git a/test/plugin/dns/main_linux.go b/test/plugin/dns/main_linux.go index 59cb24f50f..44201b4767 100644 --- a/test/plugin/dns/main_linux.go +++ b/test/plugin/dns/main_linux.go @@ -52,7 +52,7 @@ func main() { defer cancel() c := cache.New(pubsub.New()) - e := enricher.New(ctx, c) + e := enricher.New(ctx, c, false) e.Run() err = tt.Generate(ctxTimeout) From f5cee82467427b08f18ae56df41c6b329cf03a90 Mon Sep 17 00:00:00 2001 From: beegiik Date: Mon, 1 Sep 2025 11:01:47 +0100 Subject: [PATCH 4/9] Polishing --- cmd/bootstrap_manager.go | 10 ++--- cmd/standalone/daemon.go | 24 ++++++------ .../controller/helm/retina/values.yaml | 2 + pkg/controllers/cache/standalone/cache.go | 37 ++++++++++--------- .../cache/standalone/cache_test.go | 6 +-- .../daemon/standalone/controller_test.go | 2 +- pkg/enricher/enricher_test.go | 4 +- 7 files changed, 44 insertions(+), 41 deletions(-) diff --git a/cmd/bootstrap_manager.go b/cmd/bootstrap_manager.go index 2eb61caa4c..2a787f4b68 100644 --- a/cmd/bootstrap_manager.go +++ b/cmd/bootstrap_manager.go @@ -23,27 +23,27 @@ const ( type BootstrapManager struct { metricsAddr string probeAddr string - enableLeaderElection bool configFile string + enableLeaderElection bool } func NewBootstrapManager(metricsAddr, probeAddr, configFile string, enableLeaderElection bool) *BootstrapManager { return &BootstrapManager{ metricsAddr: metricsAddr, probeAddr: probeAddr, - enableLeaderElection: enableLeaderElection, configFile: configFile, + enableLeaderElection: enableLeaderElection, } } -func (b *BootstrapManager) Start() error { +func (bm *BootstrapManager) Start() error { if buildinfo.ApplicationInsightsID != "" { telemetry.InitAppInsights(buildinfo.ApplicationInsightsID, buildinfo.Version) defer telemetry.ShutdownAppInsights() defer telemetry.TrackPanic() } - daemonConfig, err := config.GetConfig(b.configFile) + daemonConfig, err := config.GetConfig(bm.configFile) if err != nil { panic(err) } @@ -76,7 +76,7 @@ func (b *BootstrapManager) Start() error { return nil } - d := standard.NewDaemon(daemonConfig, b.metricsAddr, b.probeAddr, b.enableLeaderElection) + d := standard.NewDaemon(daemonConfig, bm.metricsAddr, bm.probeAddr, bm.enableLeaderElection) if err := d.Start(zl); err != nil { return fmt.Errorf("starting daemon: %w", err) } diff --git a/cmd/standalone/daemon.go b/cmd/standalone/daemon.go index d359e4f953..46ce1818e5 100644 --- a/cmd/standalone/daemon.go +++ b/cmd/standalone/daemon.go @@ -5,7 +5,6 @@ package standalone import ( "fmt" - "time" "github.com/microsoft/retina/cmd/telemetry" "github.com/microsoft/retina/pkg/enricher" @@ -15,14 +14,12 @@ import ( ctrl "sigs.k8s.io/controller-runtime" "github.com/microsoft/retina/pkg/config" - "github.com/microsoft/retina/pkg/controllers/cache/standalone" - sd "github.com/microsoft/retina/pkg/controllers/daemon/standalone" + cache "github.com/microsoft/retina/pkg/controllers/cache/standalone" + controller "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" ) -const TTL = 3 * time.Minute - type Daemon struct { config *config.Config } @@ -34,27 +31,30 @@ func NewDaemon(daemonCfg *config.Config) *Daemon { } func (d *Daemon) Start(zl *log.ZapLogger) error { - zl.Info("Starting Standalone Retina daemon") - mainLogger := zl.Named("standalone-daemon").Sugar() + zl.Info("Starting Retina daemon in standalone mode") + mainLogger := zl.Named("main").Sugar() + // Initialize basic metrics and telemetry client metrics.InitializeMetrics() - tel, err := telemetry.InitializeTelemetryClient(nil, d.config, mainLogger) if err != nil { return fmt.Errorf("failed to initialize telemetry client: %w", err) } - ctx := ctrl.SetupSignalHandler() - cache := standalone.NewCache() + // Initialize cache and run enricher + ctx := ctrl.SetupSignalHandler() + cache := cache.New() enrich := enricher.New(ctx, cache, d.config.EnableStandalone) enrich.Run() + // Initialize metrics module metricsModule := sm.InitModule(ctx, enrich) - controller := sd.New(d.config, cache, metricsModule) + mainLogger.Info("Initializing RetinaEndpoint controller") + controller := controller.New(d.config, cache, metricsModule) go controller.Run(ctx) - // pod level needs to be disabled + // Standalone requires pod level to be disabled controllerMgr, err := cm.NewControllerManager(d.config, nil, tel) if err != nil { mainLogger.Fatal("Failed to create controller manager", zap.Error(err)) diff --git a/deploy/standard/manifests/controller/helm/retina/values.yaml b/deploy/standard/manifests/controller/helm/retina/values.yaml index 6bf0c9cf60..8ac2565f64 100644 --- a/deploy/standard/manifests/controller/helm/retina/values.yaml +++ b/deploy/standard/manifests/controller/helm/retina/values.yaml @@ -51,6 +51,8 @@ image: tag: "v0.0.2" enableConntrackMetrics: false +enableStandalone: false +EnableCrictl: false enablePodLevel: false remoteContext: false enableAnnotations: false diff --git a/pkg/controllers/cache/standalone/cache.go b/pkg/controllers/cache/standalone/cache.go index a13e7a6b67..cd60d4923c 100644 --- a/pkg/controllers/cache/standalone/cache.go +++ b/pkg/controllers/cache/standalone/cache.go @@ -13,14 +13,14 @@ import ( ) type Cache struct { - sync.RWMutex - l *log.ZapLogger + mu sync.RWMutex + l *log.ZapLogger // ipToEndpoint is a map of IP addresses to RetinaEndpoints (namespace/name) ipToEndpoint map[string]*common.RetinaEndpoint } -// NewCache returns a new instance of Cache -func NewCache() *Cache { +// New returns a new instance of Cache +func New() *Cache { c := &Cache{ l: log.Logger().Named("Cache"), ipToEndpoint: make(map[string]*common.RetinaEndpoint), @@ -30,8 +30,8 @@ func NewCache() *Cache { // GetAllIPs returns a list of all IPs in the cache func (c *Cache) GetAllIPs() []string { - c.RLock() - defer c.RUnlock() + c.mu.RLock() + defer c.mu.RUnlock() ips := make([]string, 0, len(c.ipToEndpoint)) for ip := range c.ipToEndpoint { @@ -40,17 +40,17 @@ func (c *Cache) GetAllIPs() []string { return ips } -// GetPodByIP returns the RetinaEndpoint for the given IP +// GetPodByIP returns the retina endpoint for the given IP func (c *Cache) GetPodByIP(ip string) *common.RetinaEndpoint { - c.RLock() - defer c.RUnlock() + c.mu.RLock() + defer c.mu.RUnlock() return c.ipToEndpoint[ip] } // UpdateRetinaEndpoint updates the cache with the given retina endpoint func (c *Cache) UpdateRetinaEndpoint(ep *common.RetinaEndpoint) error { - c.Lock() - defer c.Unlock() + c.mu.Lock() + defer c.mu.Unlock() return c.updateEndpoint(ep) } @@ -68,14 +68,14 @@ func (c *Cache) updateEndpoint(ep *common.RetinaEndpoint) error { } } c.ipToEndpoint[ip] = ep - c.l.Info("Added RetinaEndpoint in cache", zap.String("ip", ip), zap.String("namespace", ep.Namespace()), zap.String("name", ep.Name())) + c.l.Info("Added retina endpoint to cache", zap.String("ip", ip), zap.String("namespace", ep.Namespace()), zap.String("name", ep.Name())) return nil } // DeleteRetinaEndpoint deletes the given retina endpoint from the cache func (c *Cache) DeleteRetinaEndpoint(epKey string) error { - c.Lock() - defer c.Unlock() + c.mu.Lock() + defer c.mu.Unlock() return c.deleteEndpoint(epKey) } @@ -83,17 +83,18 @@ func (c *Cache) DeleteRetinaEndpoint(epKey string) error { func (c *Cache) deleteEndpoint(epKey string) error { if ep, exists := c.ipToEndpoint[epKey]; exists { delete(c.ipToEndpoint, epKey) - c.l.Info("Deleted RetinaEndpoint from cache", zap.String("ip", epKey), zap.String("namespace", ep.Namespace()), zap.String("name", ep.Name())) + c.l.Info("Deleted retina endpoint from cache", zap.String("ip", epKey), zap.String("namespace", ep.Namespace()), zap.String("name", ep.Name())) return nil } return nil } +// Clear resets the ip to endpoint map func (c *Cache) Clear() { - c.Lock() - defer c.Unlock() + c.mu.Lock() + defer c.mu.Unlock() c.ipToEndpoint = make(map[string]*common.RetinaEndpoint) - c.l.Info("Cleared all RetinaEndpoints from cache") + c.l.Info("Cleared all retina endpoints from cache") } // No op diff --git a/pkg/controllers/cache/standalone/cache_test.go b/pkg/controllers/cache/standalone/cache_test.go index 0bdc3e7ab3..9616ee84fc 100644 --- a/pkg/controllers/cache/standalone/cache_test.go +++ b/pkg/controllers/cache/standalone/cache_test.go @@ -22,7 +22,7 @@ func TestCacheAddEndpoint(t *testing.T) { if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { t.Errorf("Error setting up logger: %s", err) } - c := NewCache() + c := New() tests := []struct { name string @@ -69,7 +69,7 @@ func TestCacheDeleteEndpoint(t *testing.T) { if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { t.Errorf("Error setting up logger: %s", err) } - c := NewCache() + c := New() ip, err := ep1.PrimaryIP() if err != nil { t.Fatalf("failed to get IP for endpoint: %v", err) @@ -112,7 +112,7 @@ func TestCacheGetAllIPs(t *testing.T) { if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { t.Errorf("Error setting up logger: %s", err) } - c := NewCache() + c := New() ep4 := common.NewRetinaEndpoint("pod4", "ns4", &common.IPAddresses{IPv4: net.ParseIP("10.0.0.4")}) tests := []struct { diff --git a/pkg/controllers/daemon/standalone/controller_test.go b/pkg/controllers/daemon/standalone/controller_test.go index f1a9dc240c..ca3422bfd0 100644 --- a/pkg/controllers/daemon/standalone/controller_test.go +++ b/pkg/controllers/daemon/standalone/controller_test.go @@ -34,7 +34,7 @@ func TestStandaloneController_Reconcile(t *testing.T) { mockSource := utils.NewMockSource(ctrl) // Cache - cache := standalone.NewCache() + cache := standalone.New() // Metrics module metricsModule := sm.InitModule(ctx, nil) diff --git a/pkg/enricher/enricher_test.go b/pkg/enricher/enricher_test.go index 9413fff630..70334c6015 100644 --- a/pkg/enricher/enricher_test.go +++ b/pkg/enricher/enricher_test.go @@ -172,7 +172,7 @@ func TestEnricherStandalone_WithEndpointPresent(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - cache := standalone.NewCache() + cache := standalone.New() sourceIP := "1.1.1.1" // Add endpoint to cache @@ -240,7 +240,7 @@ func TestEnricherStandalone_WithEndpointAbsent(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - cache := standalone.NewCache() + cache := standalone.New() sourceIP := "9.9.9.9" // No endpoint added to cache enricher := New(ctx, cache, true) From cf4915a522495dd238dcdede93c4b4ed9643a399 Mon Sep 17 00:00:00 2001 From: beegiik Date: Mon, 1 Sep 2025 11:47:59 +0100 Subject: [PATCH 5/9] Polishing --- .../cache/standalone/cache_test.go | 97 ++++++++++--------- 1 file changed, 49 insertions(+), 48 deletions(-) diff --git a/pkg/controllers/cache/standalone/cache_test.go b/pkg/controllers/cache/standalone/cache_test.go index 9616ee84fc..96b720178a 100644 --- a/pkg/controllers/cache/standalone/cache_test.go +++ b/pkg/controllers/cache/standalone/cache_test.go @@ -22,37 +22,39 @@ func TestCacheAddEndpoint(t *testing.T) { if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { t.Errorf("Error setting up logger: %s", err) } - c := New() tests := []struct { name string endpoint *common.RetinaEndpoint expectedPod string - expectedNS string + expectedNs string }{ { name: "Add new endpoint", endpoint: ep1, expectedPod: ep1.Name(), - expectedNS: ep1.Namespace(), + expectedNs: ep1.Namespace(), }, { name: "Add identical endpoint", endpoint: ep3, expectedPod: ep1.Name(), - expectedNS: ep1.Namespace(), + expectedNs: ep1.Namespace(), }, { name: "Update endpoint info for same IP", endpoint: ep2, expectedPod: ep2.Name(), - expectedNS: ep2.Namespace(), + expectedNs: ep2.Namespace(), }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - c.UpdateRetinaEndpoint(tt.endpoint) + c := New() + + err := c.UpdateRetinaEndpoint(tt.endpoint) + require.NoError(t, err) ip, err := tt.endpoint.PrimaryIP() require.NoError(t, err) @@ -60,7 +62,7 @@ func TestCacheAddEndpoint(t *testing.T) { got := c.GetPodByIP(ip) require.NotNil(t, got, "Expected retina endpoint, got nil") require.Equal(t, tt.expectedPod, got.Name()) - require.Equal(t, tt.expectedNS, got.Namespace()) + require.Equal(t, tt.expectedNs, got.Namespace()) }) } } @@ -69,40 +71,40 @@ func TestCacheDeleteEndpoint(t *testing.T) { if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { t.Errorf("Error setting up logger: %s", err) } - c := New() - ip, err := ep1.PrimaryIP() - if err != nil { - t.Fatalf("failed to get IP for endpoint: %v", err) - } + + ip1, err := ep1.PrimaryIP() + require.NoError(t, err) tests := []struct { name string - setup func() - ip string + add []*common.RetinaEndpoint + deleteIP string expectedEndpoint *common.RetinaEndpoint }{ { - name: "Delete existing endpoint", - setup: func() { - c.UpdateRetinaEndpoint(ep1) - }, - ip: ip, + name: "Delete existing endpoint", + add: []*common.RetinaEndpoint{ep1}, + deleteIP: ip1, expectedEndpoint: nil, }, { name: "Delete non-existing pod (no-op)", - setup: func() {}, - ip: "10.0.0.2", + add: []*common.RetinaEndpoint{}, + deleteIP: "10.0.0.2", expectedEndpoint: nil, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - tt.setup() - c.DeleteRetinaEndpoint(tt.ip) + c := New() - got := c.GetPodByIP(tt.ip) + for _, ep := range tt.add { + require.NoError(t, c.UpdateRetinaEndpoint(ep)) + } + require.NoError(t, c.DeleteRetinaEndpoint(tt.deleteIP)) + + got := c.GetPodByIP(tt.deleteIP) require.Equal(t, tt.expectedEndpoint, got) }) } @@ -112,52 +114,51 @@ func TestCacheGetAllIPs(t *testing.T) { if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { t.Errorf("Error setting up logger: %s", err) } - c := New() ep4 := common.NewRetinaEndpoint("pod4", "ns4", &common.IPAddresses{IPv4: net.ParseIP("10.0.0.4")}) tests := []struct { name string - actions func() + add []*common.RetinaEndpoint + delete []string wantIPs []string }{ { - name: "Add ep1 and ep2", - actions: func() { - _ = c.UpdateRetinaEndpoint(ep1) - _ = c.UpdateRetinaEndpoint(ep2) - }, + name: "Add two IPs", + add: []*common.RetinaEndpoint{ep1, ep2}, wantIPs: []string{"10.0.0.1"}, }, { - name: "Add ep4", - actions: func() { - _ = c.UpdateRetinaEndpoint(ep4) - }, + name: "Add two unique IPs", + add: []*common.RetinaEndpoint{ep1, ep4}, wantIPs: []string{"10.0.0.1", "10.0.0.4"}, }, { - name: "Delete ep1", - actions: func() { - ip1, _ := ep1.PrimaryIP() - _ = c.DeleteRetinaEndpoint(ip1) - }, + name: "Add two unique IPs and delete one IP", + add: []*common.RetinaEndpoint{ep1, ep4}, + delete: []string{"10.0.0.1"}, wantIPs: []string{"10.0.0.4"}, }, { - name: "Delete ep4", - actions: func() { - ip4, _ := ep4.PrimaryIP() - _ = c.DeleteRetinaEndpoint(ip4) - }, + name: "Add two unique IPs and delete two IPs", + add: []*common.RetinaEndpoint{ep1, ep4}, + delete: []string{"10.0.0.1", "10.0.0.4"}, wantIPs: []string{}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - tt.actions() - ips := c.GetAllIPs() - require.ElementsMatch(t, tt.wantIPs, ips, "IPs mismatch for test: %s", tt.name) + c := New() + + for _, ep := range tt.add { + require.NoError(t, c.UpdateRetinaEndpoint(ep)) + } + for _, ip := range tt.delete { + require.NoError(t, c.DeleteRetinaEndpoint(ip)) + } + + gotIPs := c.GetAllIPs() + require.ElementsMatch(t, tt.wantIPs, gotIPs, "IPs mismatch for test: %s", tt.name) }) } } From 6e1ddcba20bf7b63eedc8aeb8338e3d2f9b65ccc Mon Sep 17 00:00:00 2001 From: beegiik Date: Mon, 1 Sep 2025 12:10:45 +0100 Subject: [PATCH 6/9] Polishing --- .../daemon/standalone/controller.go | 64 ++++++++++--------- .../daemon/standalone/controller_test.go | 17 ++--- 2 files changed, 40 insertions(+), 41 deletions(-) diff --git a/pkg/controllers/daemon/standalone/controller.go b/pkg/controllers/daemon/standalone/controller.go index 8070cdd446..a9741ed3d2 100644 --- a/pkg/controllers/daemon/standalone/controller.go +++ b/pkg/controllers/daemon/standalone/controller.go @@ -18,8 +18,8 @@ import ( "go.uber.org/zap" ) -type StandaloneController struct { - // interface for fetching endpoint information +type Controller struct { + // interface for fetching retina endpoint information source utils.Source // cache to hold retina endpoints cache *standalone.Cache @@ -29,7 +29,8 @@ type StandaloneController struct { l *log.ZapLogger } -func New(config *kcfg.Config, cache *standalone.Cache, metricsModule *sm.Module) *StandaloneController { +// New creates a new instance of the standalone controller +func New(config *kcfg.Config, cache *standalone.Cache, metricsModule *sm.Module) *Controller { var source utils.Source if config.EnableCrictl { @@ -38,60 +39,60 @@ func New(config *kcfg.Config, cache *standalone.Cache, metricsModule *sm.Module) source = &utils.StatefileSource{} } - return &StandaloneController{ + return &Controller{ source: source, cache: cache, config: config, metricsModule: metricsModule, - l: log.Logger().Named(string("StandaloneController")), + l: log.Logger().Named(string("Controller")), } } -// Reconcile syncs the state of the endpoints with the desired state -func (sc *StandaloneController) Reconcile(ctx context.Context) error { - sc.l.Info("Starting standalone reconciliation") +// Reconcile syncs the state of the running endpoints with the existing endpoints in cache +func (c *Controller) Reconcile(ctx context.Context) error { + c.l.Info("Reconciling retina endpoints") - srcEndpoints, err := sc.source.GetAllEndpoints() + // Retrieve running pod information from the corresponding source + runningEps, err := c.source.GetAllEndpoints() if err != nil { - sc.l.Error("Failed to get all endpoints", zap.Error(err)) + c.l.Error("failed to get endpoints", zap.Error(err)) return err } - srcIPs := make(map[string]*common.RetinaEndpoint, len(srcEndpoints)) - for _, ep := range srcEndpoints { + runningIPs := make(map[string]*common.RetinaEndpoint) + for _, ep := range runningEps { ip, err := ep.PrimaryIP() - if err != nil { + if err != nil || ip == "" { continue } - if ip == "" { - continue - } - srcIPs[ip] = ep + runningIPs[ip] = ep } - cachedIPs := sc.cache.GetAllIPs() + cachedIPs := c.cache.GetAllIPs() + // Remove IPs not in the running set for _, ip := range cachedIPs { - if _, exists := srcIPs[ip]; !exists { - sc.cache.DeleteRetinaEndpoint(ip) - // sc.metricsModule.RemoveSeries(ip) + if _, exists := runningIPs[ip]; !exists { + c.cache.DeleteRetinaEndpoint(ip) } } - for ip, ep := range srcIPs { - if err := sc.cache.UpdateRetinaEndpoint(ep); err != nil { - sc.l.Error("Failed to update retina endpoint", zap.String("ip", ip), zap.Error(err)) + // Update IPs that are not existing in cache + for ip, ep := range runningIPs { + if err := c.cache.UpdateRetinaEndpoint(ep); err != nil { + c.l.Error("failed to update retina endpoint", zap.String("ip", ip), zap.Error(err)) return err } } - sc.metricsModule.Reconcile(ctx) - sc.l.Info("Standalone reconciliation completed") + c.metricsModule.Reconcile(ctx) + c.l.Info("Reconciliation completed") return nil } -func (sc *StandaloneController) Run(ctx context.Context) { - sc.l.Info("Starting Standalone Controller") +// Run starts the controller loop +func (sc *Controller) Run(ctx context.Context) { + sc.l.Info("Starting controller") ticker := time.NewTicker(sc.config.MetricsInterval / 2) defer ticker.Stop() @@ -103,14 +104,15 @@ func (sc *StandaloneController) Run(ctx context.Context) { return case <-ticker.C: if err := sc.Reconcile(ctx); err != nil { - sc.l.Error("Failed to reconcile", zap.Error(err)) + sc.l.Error("failed to reconcile", zap.Error(err)) } } } } -func (sc *StandaloneController) Stop() { - sc.l.Info("Stopping Standalone Controller") +// Stop stops the controller and cleans up resources +func (sc *Controller) Stop() { + sc.l.Info("Stopping controller") sc.cache.Clear() sc.metricsModule.Clear() } diff --git a/pkg/controllers/daemon/standalone/controller_test.go b/pkg/controllers/daemon/standalone/controller_test.go index ca3422bfd0..dfec5e2996 100644 --- a/pkg/controllers/daemon/standalone/controller_test.go +++ b/pkg/controllers/daemon/standalone/controller_test.go @@ -20,7 +20,7 @@ import ( "go.uber.org/mock/gomock" ) -func TestStandaloneController_Reconcile(t *testing.T) { +func TestControllerReconcile(t *testing.T) { ctrl := gomock.NewController(t) defer ctrl.Finish() @@ -28,8 +28,6 @@ func TestStandaloneController_Reconcile(t *testing.T) { _, err := log.SetupZapLogger(log.GetDefaultLogOpts()) assert.NoError(t, err) - ctx := context.Background() - // Mock source mockSource := utils.NewMockSource(ctrl) @@ -37,17 +35,18 @@ func TestStandaloneController_Reconcile(t *testing.T) { cache := standalone.New() // Metrics module + ctx := context.Background() metricsModule := sm.InitModule(ctx, nil) // Prepopulate cache with an endpoint to simulate deletion - oldEndpoint := common.NewRetinaEndpoint("old-pod", "default", &common.IPAddresses{IPv4: net.ParseIP("1.1.1.2")}) - require.NoError(t, cache.UpdateRetinaEndpoint(oldEndpoint)) + oldEp := common.NewRetinaEndpoint("old-pod", "default", &common.IPAddresses{IPv4: net.ParseIP("1.1.1.2")}) + require.NoError(t, cache.UpdateRetinaEndpoint(oldEp)) - // Endpoint returned by the source + // New endpoint returned by the source newEndpoint := common.NewRetinaEndpoint("new-pod", "default", &common.IPAddresses{IPv4: net.ParseIP("1.1.1.1")}) mockSource.EXPECT().GetAllEndpoints().Return([]*common.RetinaEndpoint{newEndpoint}, nil) - // Setup controller + // Setup test controller cfg := &kcfg.Config{MetricsInterval: 1, EnableCrictl: false} controller := New(cfg, cache, metricsModule) controller.source = mockSource // inject mock source @@ -61,9 +60,7 @@ func TestStandaloneController_Reconcile(t *testing.T) { assert.Len(t, cachedIPs, 1, "only new endpoint should remain in cache") assert.Contains(t, cachedIPs, "1.1.1.1") - // Validate old endpoint removed - assert.NotContains(t, cachedIPs, "1.1.1.2") - + // Stop the controller and validate cleanup controller.Stop() assert.Equal(t, len(controller.cache.GetAllIPs()), 0) } From 973739d6e3c9b045c7bd0d7eefbbd26fb0749033 Mon Sep 17 00:00:00 2001 From: beegiik Date: Mon, 1 Sep 2025 13:53:34 +0100 Subject: [PATCH 7/9] Polishing --- pkg/controllers/daemon/standalone/utils/ctrinfo.go | 10 ++++++---- .../daemon/standalone/utils/ctrinfo_test.go | 3 +-- pkg/controllers/daemon/standalone/utils/mock_source.go | 2 +- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/pkg/controllers/daemon/standalone/utils/ctrinfo.go b/pkg/controllers/daemon/standalone/utils/ctrinfo.go index 86e47bf738..df55c29ae3 100644 --- a/pkg/controllers/daemon/standalone/utils/ctrinfo.go +++ b/pkg/controllers/daemon/standalone/utils/ctrinfo.go @@ -46,9 +46,10 @@ var ( ) func (cs *CtrinfoSource) GetAllEndpoints() ([]*common.RetinaEndpoint, error) { + // Using crictl to get all running pods runningPods, err := crictlCommand("cmd", "/c", "crictl", "pods", "-q") if err != nil { - return nil, fmt.Errorf("%v: %v", errGetPods, err) + return nil, fmt.Errorf("%w: %w", errGetPods, err) } podIDs := strings.Split(strings.TrimSpace(runningPods), "\n") @@ -58,19 +59,20 @@ func (cs *CtrinfoSource) GetAllEndpoints() ([]*common.RetinaEndpoint, error) { continue } + // Using crictl to get pod spec podSpec, err := crictlCommand("cmd", "/c", "crictl", "inspectp", podID) if err != nil { - return nil, fmt.Errorf("%w: %v", errInspectPod, err) + return nil, fmt.Errorf("%w: %w", errInspectPod, err) } var spec PodSpec if err := json.Unmarshal([]byte(podSpec), &spec); err != nil { - return nil, fmt.Errorf("%w: %v", errJSONRead, err) + return nil, fmt.Errorf("%w: %w", errJSONRead, err) } ip := net.ParseIP(spec.Status.Network.IP) + // Skip pods with invalid or empty IPs if ip == nil { - // Skip pods with invalid or empty IPs continue } diff --git a/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go b/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go index 8e07521356..c0d39a3e31 100644 --- a/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go +++ b/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go @@ -102,8 +102,7 @@ func TestCtrinfoGetAllEndpoints(t *testing.T) { require.NoError(t, err) require.Len(t, endpoints, tt.expectedCount) if tt.expectedCount > 0 { - ep := endpoints[0] - require.Equal(t, tt.expectedRetinaEndpoint, ep) + require.Equal(t, tt.expectedRetinaEndpoint, endpoints[0]) } } }) diff --git a/pkg/controllers/daemon/standalone/utils/mock_source.go b/pkg/controllers/daemon/standalone/utils/mock_source.go index 450303f887..d69482b927 100644 --- a/pkg/controllers/daemon/standalone/utils/mock_source.go +++ b/pkg/controllers/daemon/standalone/utils/mock_source.go @@ -5,7 +5,7 @@ // // Code generated by MockGen. DO NOT EDIT. -// Source: types.go +// Source: github.com/microsoft/retina/pkg/controllers/daemon/standalone/utils/types.go (interfaces: Source) // Package utils is a generated GoMock package. package utils From d0ea94377e1968b91360f1f5723a06dc271af6ce Mon Sep 17 00:00:00 2001 From: beegiik Date: Mon, 1 Sep 2025 14:04:57 +0100 Subject: [PATCH 8/9] Polishing --- cmd/standalone/daemon.go | 8 ++++---- pkg/controllers/daemon/standalone/controller.go | 5 ++++- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/cmd/standalone/daemon.go b/cmd/standalone/daemon.go index 46ce1818e5..0c29b53ebf 100644 --- a/cmd/standalone/daemon.go +++ b/cmd/standalone/daemon.go @@ -15,7 +15,7 @@ import ( "github.com/microsoft/retina/pkg/config" cache "github.com/microsoft/retina/pkg/controllers/cache/standalone" - controller "github.com/microsoft/retina/pkg/controllers/daemon/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" ) @@ -43,15 +43,15 @@ func (d *Daemon) Start(zl *log.ZapLogger) error { // Initialize cache and run enricher ctx := ctrl.SetupSignalHandler() - cache := cache.New() - enrich := enricher.New(ctx, cache, d.config.EnableStandalone) + controllerCache := cache.New() + enrich := enricher.New(ctx, controllerCache, d.config.EnableStandalone) enrich.Run() // Initialize metrics module metricsModule := sm.InitModule(ctx, enrich) mainLogger.Info("Initializing RetinaEndpoint controller") - controller := controller.New(d.config, cache, metricsModule) + controller := sc.New(d.config, controllerCache, metricsModule) go controller.Run(ctx) // Standalone requires pod level to be disabled diff --git a/pkg/controllers/daemon/standalone/controller.go b/pkg/controllers/daemon/standalone/controller.go index a9741ed3d2..8d3a8eb881 100644 --- a/pkg/controllers/daemon/standalone/controller.go +++ b/pkg/controllers/daemon/standalone/controller.go @@ -73,7 +73,10 @@ func (c *Controller) Reconcile(ctx context.Context) error { // Remove IPs not in the running set for _, ip := range cachedIPs { if _, exists := runningIPs[ip]; !exists { - c.cache.DeleteRetinaEndpoint(ip) + if err := c.cache.DeleteRetinaEndpoint(ip); err != nil { + c.l.Error("failed to delete retina endpoint", zap.String("ip", ip), zap.Error(err)) + return err + } } } From 121df4862f809ac5cf5e4420177be878c3a06e70 Mon Sep 17 00:00:00 2001 From: beegiik Date: Mon, 1 Sep 2025 15:21:36 +0100 Subject: [PATCH 9/9] Polishing --- pkg/enricher/enricher.go | 20 ++++++++++---------- pkg/enricher/enricher_test.go | 35 ++++++++++++++++++----------------- 2 files changed, 28 insertions(+), 27 deletions(-) diff --git a/pkg/enricher/enricher.go b/pkg/enricher/enricher.go index fea6cdba42..aac2f8a5d0 100644 --- a/pkg/enricher/enricher.go +++ b/pkg/enricher/enricher.go @@ -12,7 +12,7 @@ import ( v1 "github.com/cilium/cilium/pkg/hubble/api/v1" "github.com/cilium/cilium/pkg/hubble/container" "github.com/microsoft/retina/pkg/common" - "github.com/microsoft/retina/pkg/controllers/cache" + c "github.com/microsoft/retina/pkg/controllers/cache" "github.com/microsoft/retina/pkg/log" "go.uber.org/zap" ) @@ -31,7 +31,7 @@ type Enricher struct { l *log.ZapLogger // cache is the cache of all the objects - cache cache.CacheInterface + cache c.CacheInterface inputRing *container.Ring @@ -43,7 +43,7 @@ type Enricher struct { enableStandalone bool } -func New(ctx context.Context, cache cache.CacheInterface, enableStandalone bool) *Enricher { +func New(ctx context.Context, cache c.CacheInterface, enableStandalone bool) *Enricher { once.Do(func() { ir := container.NewRing(container.Capacity1023) e = &Enricher{ @@ -112,22 +112,22 @@ func (e *Enricher) enrich(ev *v1.Event) { // enrichStandalone takes the flow and enriches it with information from the standalone cache func (e *Enricher) enrichStandalone(ev *v1.Event) { - flow := ev.Event.(*flow.Flow) + fl := ev.Event.(*flow.Flow) - if flow.IP.Source == "" { + if fl.IP.Source == "" { e.l.Debug("source IP is empty") return } - srcObj := e.cache.GetPodByIP(flow.IP.Source) + srcObj := e.cache.GetPodByIP(fl.IP.Source) if srcObj != nil { - flow.Source = e.getEndpoint(srcObj) - e.l.Debug("enriched flow", zap.Any("flow", flow)) + fl.Source = e.getEndpoint(srcObj) + e.l.Debug("enriched flow", zap.Any("flow", fl)) } else { - flow.Source = nil + fl.Source = nil } - ev.Event = flow + ev.Event = fl e.export(ev) } diff --git a/pkg/enricher/enricher_test.go b/pkg/enricher/enricher_test.go index 70334c6015..a70425c506 100644 --- a/pkg/enricher/enricher_test.go +++ b/pkg/enricher/enricher_test.go @@ -159,7 +159,7 @@ func addEvent(e *Enricher, sourceIP, destIP string) { e.Write(ev) } -func TestEnricherStandalone_WithEndpointPresent(t *testing.T) { +func TestEnricherStandaloneWithEndpointPresent(t *testing.T) { opts := log.GetDefaultLogOpts() opts.Level = "debug" if _, err := log.SetupZapLogger(opts); err != nil { @@ -172,14 +172,15 @@ func TestEnricherStandalone_WithEndpointPresent(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - cache := standalone.New() + testCache := standalone.New() sourceIP := "1.1.1.1" // Add endpoint to cache endpoint := common.NewRetinaEndpoint("pod1", "ns1", &common.IPAddresses{IPv4: net.ParseIP(sourceIP)}) - require.NoError(t, cache.UpdateRetinaEndpoint(endpoint)) + require.NoError(t, testCache.UpdateRetinaEndpoint(endpoint)) - enricher := New(ctx, cache, true) + // Create the enricher with standalone enabled + enricher := New(ctx, testCache, true) var wg sync.WaitGroup wg.Add(1) @@ -210,12 +211,12 @@ func TestEnricherStandalone_WithEndpointPresent(t *testing.T) { if ev == nil { break } - flow := ev.Event.(*flow.Flow) - sourceFlow := flow.GetSource() + fl := ev.Event.(*flow.Flow) + receivedFlow := fl.GetSource() - require.NotNil(t, sourceFlow, "Expected flow") - require.Equal(t, "pod1", sourceFlow.GetPodName()) - require.Equal(t, "ns1", sourceFlow.GetNamespace()) + require.NotNil(t, receivedFlow, "Expected flow") + require.Equal(t, "pod1", receivedFlow.GetPodName()) + require.Equal(t, "ns1", receivedFlow.GetNamespace()) count++ } @@ -227,7 +228,7 @@ func TestEnricherStandalone_WithEndpointPresent(t *testing.T) { wg.Wait() } -func TestEnricherStandalone_WithEndpointAbsent(t *testing.T) { +func TestEnricherStandaloneWithEndpointAbsent(t *testing.T) { opts := log.GetDefaultLogOpts() opts.Level = "debug" if _, err := log.SetupZapLogger(opts); err != nil { @@ -240,10 +241,11 @@ func TestEnricherStandalone_WithEndpointAbsent(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() - cache := standalone.New() - sourceIP := "9.9.9.9" // No endpoint added to cache + testCache := standalone.New() + sourceIP := "9.9.9.9" // No endpoint present in cache - enricher := New(ctx, cache, true) + // Create the enricher with standalone enabled + enricher := New(ctx, testCache, true) var wg sync.WaitGroup wg.Add(1) @@ -274,10 +276,9 @@ func TestEnricherStandalone_WithEndpointAbsent(t *testing.T) { if ev == nil { break } - flow := ev.Event.(*flow.Flow) - sourceFlow := flow.GetSource() - - require.Nil(t, sourceFlow) + fl := ev.Event.(*flow.Flow) + receivedFlow := fl.GetSource() + require.Nil(t, receivedFlow) count++ }