diff --git a/cmd/bootstrap_manager.go b/cmd/bootstrap_manager.go new file mode 100644 index 0000000000..2a787f4b68 --- /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 + configFile string + enableLeaderElection bool +} + +func NewBootstrapManager(metricsAddr, probeAddr, configFile string, enableLeaderElection bool) *BootstrapManager { + return &BootstrapManager{ + metricsAddr: metricsAddr, + probeAddr: probeAddr, + configFile: configFile, + enableLeaderElection: enableLeaderElection, + } +} + +func (bm *BootstrapManager) Start() error { + if buildinfo.ApplicationInsightsID != "" { + telemetry.InitAppInsights(buildinfo.ApplicationInsightsID, buildinfo.Version) + defer telemetry.ShutdownAppInsights() + defer telemetry.TrackPanic() + } + + daemonConfig, err := config.GetConfig(bm.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, bm.metricsAddr, bm.probeAddr, bm.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..0c29b53ebf --- /dev/null +++ b/cmd/standalone/daemon.go @@ -0,0 +1,78 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package standalone + +import ( + "fmt" + + "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" + cache "github.com/microsoft/retina/pkg/controllers/cache/standalone" + sc "github.com/microsoft/retina/pkg/controllers/daemon/standalone" + cm "github.com/microsoft/retina/pkg/managers/controllermanager" + sm "github.com/microsoft/retina/pkg/module/metrics/standalone" +) + +type Daemon struct { + config *config.Config +} + +func NewDaemon(daemonCfg *config.Config) *Daemon { + return &Daemon{ + config: daemonCfg, + } +} + +func (d *Daemon) Start(zl *log.ZapLogger) error { + 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) + } + + // Initialize cache and run enricher + ctx := ctrl.SetupSignalHandler() + 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 := sc.New(d.config, controllerCache, metricsModule) + go controller.Run(ctx) + + // 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)) + } + 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..8ef4daa0dd 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,10 +188,10 @@ 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) + 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 { @@ -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/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/go.mod b/go.mod index 797135515a..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 @@ -317,6 +318,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 ( @@ -370,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 @@ -659,7 +662,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..cd60d4923c --- /dev/null +++ b/pkg/controllers/cache/standalone/cache.go @@ -0,0 +1,112 @@ +// 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 { + mu sync.RWMutex + l *log.ZapLogger + // ipToEndpoint is a map of IP addresses to RetinaEndpoints (namespace/name) + ipToEndpoint map[string]*common.RetinaEndpoint +} + +// New returns a new instance of Cache +func New() *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.mu.RLock() + defer c.mu.RUnlock() + + ips := make([]string, 0, len(c.ipToEndpoint)) + for ip := range c.ipToEndpoint { + ips = append(ips, ip) + } + return ips +} + +// GetPodByIP returns the retina endpoint for the given IP +func (c *Cache) GetPodByIP(ip string) *common.RetinaEndpoint { + 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.mu.Lock() + defer c.mu.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 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.mu.Lock() + defer c.mu.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 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.mu.Lock() + defer c.mu.Unlock() + c.ipToEndpoint = make(map[string]*common.RetinaEndpoint) + c.l.Info("Cleared all retina endpoints 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..96b720178a --- /dev/null +++ b/pkg/controllers/cache/standalone/cache_test.go @@ -0,0 +1,164 @@ +// 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) + } + + 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 := New() + + err := c.UpdateRetinaEndpoint(tt.endpoint) + require.NoError(t, err) + + 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) + } + + ip1, err := ep1.PrimaryIP() + require.NoError(t, err) + + tests := []struct { + name string + add []*common.RetinaEndpoint + deleteIP string + expectedEndpoint *common.RetinaEndpoint + }{ + { + name: "Delete existing endpoint", + add: []*common.RetinaEndpoint{ep1}, + deleteIP: ip1, + expectedEndpoint: nil, + }, + { + name: "Delete non-existing pod (no-op)", + add: []*common.RetinaEndpoint{}, + deleteIP: "10.0.0.2", + expectedEndpoint: nil, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := New() + + 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) + }) + } +} + +func TestCacheGetAllIPs(t *testing.T) { + if _, err := log.SetupZapLogger(log.GetDefaultLogOpts()); err != nil { + t.Errorf("Error setting up logger: %s", err) + } + ep4 := common.NewRetinaEndpoint("pod4", "ns4", &common.IPAddresses{IPv4: net.ParseIP("10.0.0.4")}) + + tests := []struct { + name string + add []*common.RetinaEndpoint + delete []string + wantIPs []string + }{ + { + name: "Add two IPs", + add: []*common.RetinaEndpoint{ep1, ep2}, + wantIPs: []string{"10.0.0.1"}, + }, + { + name: "Add two unique IPs", + add: []*common.RetinaEndpoint{ep1, ep4}, + wantIPs: []string{"10.0.0.1", "10.0.0.4"}, + }, + { + 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: "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) { + 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) + }) + } +} diff --git a/pkg/controllers/daemon/standalone/controller.go b/pkg/controllers/daemon/standalone/controller.go new file mode 100644 index 0000000000..8d3a8eb881 --- /dev/null +++ b/pkg/controllers/daemon/standalone/controller.go @@ -0,0 +1,121 @@ +// 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 Controller struct { + // interface for fetching retina endpoint information + source utils.Source + // cache to hold retina endpoints + cache *standalone.Cache + + metricsModule *sm.Module + config *kcfg.Config + l *log.ZapLogger +} + +// 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 { + source = &utils.CtrinfoSource{} + } else { + source = &utils.StatefileSource{} + } + + return &Controller{ + source: source, + cache: cache, + config: config, + metricsModule: metricsModule, + l: log.Logger().Named(string("Controller")), + } +} + +// 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") + + // Retrieve running pod information from the corresponding source + runningEps, err := c.source.GetAllEndpoints() + if err != nil { + c.l.Error("failed to get endpoints", zap.Error(err)) + return err + } + + runningIPs := make(map[string]*common.RetinaEndpoint) + for _, ep := range runningEps { + ip, err := ep.PrimaryIP() + if err != nil || ip == "" { + continue + } + runningIPs[ip] = ep + } + + cachedIPs := c.cache.GetAllIPs() + + // Remove IPs not in the running set + for _, ip := range cachedIPs { + if _, exists := runningIPs[ip]; !exists { + 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 + } + } + } + + // 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 + } + } + + c.metricsModule.Reconcile(ctx) + c.l.Info("Reconciliation completed") + return nil +} + +// 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() + + 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)) + } + } + } +} + +// 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 new file mode 100644 index 0000000000..dfec5e2996 --- /dev/null +++ b/pkg/controllers/daemon/standalone/controller_test.go @@ -0,0 +1,66 @@ +// 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 TestControllerReconcile(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + // Setup logger + _, err := log.SetupZapLogger(log.GetDefaultLogOpts()) + assert.NoError(t, err) + + // Mock source + mockSource := utils.NewMockSource(ctrl) + + // Cache + cache := standalone.New() + + // Metrics module + ctx := context.Background() + metricsModule := sm.InitModule(ctx, nil) + + // Prepopulate cache with an endpoint to simulate deletion + oldEp := common.NewRetinaEndpoint("old-pod", "default", &common.IPAddresses{IPv4: net.ParseIP("1.1.1.2")}) + require.NoError(t, cache.UpdateRetinaEndpoint(oldEp)) + + // 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 test 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") + + // Stop the controller and validate cleanup + controller.Stop() + assert.Equal(t, len(controller.cache.GetAllIPs()), 0) +} diff --git a/pkg/controllers/daemon/standalone/utils/ctrinfo.go b/pkg/controllers/daemon/standalone/utils/ctrinfo.go new file mode 100644 index 0000000000..df55c29ae3 --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/ctrinfo.go @@ -0,0 +1,101 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package utils + +import ( + "bytes" + "context" + "encoding/json" + "errors" + "fmt" + "net" + "os/exec" + "strings" + "time" + + "github.com/microsoft/retina/pkg/common" +) + +type CtrinfoSource struct{} + +type PodSpec struct { + Status Status `json:"status"` +} + +type Status struct { + Metadata Metadata `json:"metadata"` + Network PodNetwork `json:"network"` +} + +type Metadata struct { + Name string `json:"name"` + Namespace string `json:"namespace"` +} + +type PodNetwork struct { + IP string `json:"ip"` +} + +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 (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("%w: %w", errGetPods, err) + } + + podIDs := strings.Split(strings.TrimSpace(runningPods), "\n") + endpoints := []*common.RetinaEndpoint{} + for _, podID := range podIDs { + if podID == "" { + continue + } + + // Using crictl to get pod spec + podSpec, err := crictlCommand("cmd", "/c", "crictl", "inspectp", podID) + if err != nil { + 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: %w", errJSONRead, err) + } + + ip := net.ParseIP(spec.Status.Network.IP) + // Skip pods with invalid or empty IPs + if ip == nil { + continue + } + + endpoints = append(endpoints, common.NewRetinaEndpoint( + spec.Status.Metadata.Name, + spec.Status.Metadata.Namespace, + common.NewIPAddress(ip, nil), + )) + } + + return endpoints, 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/controllers/daemon/standalone/utils/ctrinfo_test.go b/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go new file mode 100644 index 0000000000..c0d39a3e31 --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/ctrinfo_test.go @@ -0,0 +1,110 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package utils + +import ( + "net" + "os" + "strings" + "testing" + + "github.com/microsoft/retina/pkg/common" + "github.com/stretchr/testify/require" + "sigs.k8s.io/kind/pkg/errors" +) + +func TestCtrinfoGetAllEndpoints(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) + + cs := &CtrinfoSource{} + + tests := []struct { + name string + podCmdOutput string + inspectCmdOutput string + getPodsErr error + inspectPodErr error + expectedErr error + expectedCount int + expectedRetinaEndpoint *common.RetinaEndpoint + }{ + { + name: "Successful get all endpoints", + podCmdOutput: "pod1\npod2\n", + inspectCmdOutput: "mock_podSpec.json", + expectedErr: nil, + expectedCount: 2, + expectedRetinaEndpoint: common.NewRetinaEndpoint( + "retina-pod", + "retina-namespace", + common.NewIPAddress(net.ParseIP("10.0.0.4"), 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", + podCmdOutput: "pod1\npod2\n", + inspectCmdOutput: invalidJSONPath, + expectedErr: errJSONRead, + 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 { + 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") + } + + endpoints, err := cs.GetAllEndpoints() + if tt.expectedErr != nil { + require.Error(t, err) + require.ErrorContains(t, err, tt.expectedErr.Error()) + require.Nil(t, endpoints) + } else { + require.NoError(t, err) + require.Len(t, endpoints, tt.expectedCount) + if tt.expectedCount > 0 { + require.Equal(t, tt.expectedRetinaEndpoint, endpoints[0]) + } + } + }) + } +} diff --git a/pkg/controllers/daemon/standalone/utils/mock_podSpec.json b/pkg/controllers/daemon/standalone/utils/mock_podSpec.json new file mode 100644 index 0000000000..70ca17934d --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/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/controllers/daemon/standalone/utils/mock_source.go b/pkg/controllers/daemon/standalone/utils/mock_source.go new file mode 100644 index 0000000000..d69482b927 --- /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: github.com/microsoft/retina/pkg/controllers/daemon/standalone/utils/types.go (interfaces: Source) + +// 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/controllers/daemon/standalone/utils/mock_statefile.json b/pkg/controllers/daemon/standalone/utils/mock_statefile.json new file mode 100644 index 0000000000..4437a77a94 --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/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/controllers/daemon/standalone/utils/statefile.go b/pkg/controllers/daemon/standalone/utils/statefile.go new file mode 100644 index 0000000000..a414402aa7 --- /dev/null +++ b/pkg/controllers/daemon/standalone/utils/statefile.go @@ -0,0 +1,84 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT license. + +package utils + +import ( + "encoding/json" + "fmt" + "net" + "os" + + "github.com/microsoft/retina/pkg/common" +) + +type StatefileSource struct{} + +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 (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) + } + + 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) + } + + 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 { + ip := ipInfo.IP + if ip == "" { + continue + } + + endpoints = append(endpoints, common.NewRetinaEndpoint( + endpoint.PodName, + endpoint.PodNamespace, + common.NewIPAddress(net.ParseIP(ip), 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/enricher.go b/pkg/enricher/enricher.go index 98013cd2ca..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,25 +31,29 @@ type Enricher struct { l *log.ZapLogger // cache is the cache of all the objects - cache cache.CacheInterface + cache c.CacheInterface inputRing *container.Ring 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 c.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) { + fl := ev.Event.(*flow.Flow) + + if fl.IP.Source == "" { + e.l.Debug("source IP is empty") + return + } + + srcObj := e.cache.GetPodByIP(fl.IP.Source) + if srcObj != nil { + fl.Source = e.getEndpoint(srcObj) + e.l.Debug("enriched flow", zap.Any("flow", fl)) + } else { + fl.Source = nil + } + + ev.Event = fl + 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/enricher_test.go b/pkg/enricher/enricher_test.go index cd05556d10..a70425c506 100644 --- a/pkg/enricher/enricher_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,134 @@ func addEvent(e *Enricher, sourceIP, destIP string) { time.Sleep(100 * time.Millisecond) e.Write(ev) } + +func TestEnricherStandaloneWithEndpointPresent(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() + + 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, testCache.UpdateRetinaEndpoint(endpoint)) + + // Create the enricher with standalone enabled + enricher := New(ctx, testCache, 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 + } + fl := ev.Event.(*flow.Flow) + receivedFlow := fl.GetSource() + + require.NotNil(t, receivedFlow, "Expected flow") + require.Equal(t, "pod1", receivedFlow.GetPodName()) + require.Equal(t, "ns1", receivedFlow.GetNamespace()) + + count++ + } + assert.Equal(t, expectedOutputCount, count, "Received event count mismatch") + }() + + time.Sleep(3 * time.Second) + cancel() + wg.Wait() +} + +func TestEnricherStandaloneWithEndpointAbsent(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() + + testCache := standalone.New() + sourceIP := "9.9.9.9" // No endpoint present in cache + + // Create the enricher with standalone enabled + enricher := New(ctx, testCache, 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 + } + fl := ev.Event.(*flow.Flow) + receivedFlow := fl.GetSource() + require.Nil(t, receivedFlow) + + count++ + } + assert.Equal(t, expectedOutputCount, count, "Received event count mismatch") + }() + + time.Sleep(3 * time.Second) + cancel() + wg.Wait() +} 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/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/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 dd93db438f..2e44147118 100644 --- a/pkg/plugin/hnsstats/hnsstats_windows.go +++ b/pkg/plugin/hnsstats/hnsstats_windows.go @@ -7,16 +7,21 @@ package hnsstats 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" "github.com/microsoft/retina/pkg/log" "github.com/microsoft/retina/pkg/metrics" "github.com/microsoft/retina/pkg/plugin/registry" "github.com/microsoft/retina/pkg/utils" + "go.uber.org/zap" ) @@ -78,12 +83,20 @@ 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 { + if enricher.IsInitialized() { + h.enricher = enricher.Instance() + h.l.Info("Standalone enricher is enabled") + } + } 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.endpointQuery.Filter = string(filter) h.l.Info("Exiting hnsstats Init...") return nil @@ -153,6 +166,9 @@ 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) } } @@ -160,6 +176,32 @@ func pullHnsStats(ctx context.Context, h *hnsstats) error { } } +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)) @@ -214,14 +256,15 @@ 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...") + + 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..2452ce16fc 100644 --- a/pkg/plugin/hnsstats/types_windows.go +++ b/pkg/plugin/hnsstats/types_windows.go @@ -10,7 +10,13 @@ import ( "github.com/Microsoft/hcsshim" "github.com/Microsoft/hcsshim/hcn" kcfg "github.com/microsoft/retina/pkg/config" + "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 +24,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 +73,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.Enricher } type HnsStatsData struct { @@ -147,3 +163,131 @@ 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 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, + 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 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)