diff --git a/central/graphql/resolvers/generated.go b/central/graphql/resolvers/generated.go index f745c069f33de..f0a4760a93fbe 100644 --- a/central/graphql/resolvers/generated.go +++ b/central/graphql/resolvers/generated.go @@ -879,6 +879,7 @@ func registerGeneratedTypes(builder generator.SchemaBuilder) { "labels: [Label!]!", "lastUpdated: Time", "name: String!", + "nodeInventory: NodeInventory", "notes: [Node_Note!]!", "operatingSystem: String!", "osImage: String!", @@ -905,6 +906,36 @@ func registerGeneratedTypes(builder generator.SchemaBuilder) { "riskScore: Float!", "version: String!", })) + utils.Must(builder.AddType("NodeInventory", []string{ + "components: NodeInventory_Components", + "nodeName: String!", + "notes: [NodeInventory_Note!]!", + "scanTime: Time", + })) + utils.Must(builder.AddType("NodeInventory_Components", []string{ + "namespace: String!", + "rhelComponents: [NodeInventory_Components_RHELComponent]!", + "rhelContentSets: [String!]!", + })) + utils.Must(builder.AddType("NodeInventory_Components_RHELComponent", []string{ + "addedBy: String!", + "arch: String!", + "executables: [NodeInventory_Components_RHELComponent_Executable]!", + "id: Int!", + "module: String!", + "name: String!", + "namespace: String!", + "version: String!", + })) + utils.Must(builder.AddType("NodeInventory_Components_RHELComponent_Executable", []string{ + "path: String!", + "requiredFeatures: [NodeInventory_Components_RHELComponent_Executable_FeatureNameVersion]!", + })) + utils.Must(builder.AddType("NodeInventory_Components_RHELComponent_Executable_FeatureNameVersion", []string{ + "name: String!", + "version: String!", + })) + generator.RegisterProtoEnum(builder, reflect.TypeOf(storage.NodeInventory_Note(0))) utils.Must(builder.AddType("NodeScan", []string{ "notes: [NodeScan_Note!]!", "operatingSystem: String!", @@ -10177,6 +10208,11 @@ func (resolver *nodeResolver) Name(ctx context.Context) string { return value } +func (resolver *nodeResolver) NodeInventory(ctx context.Context) (*nodeInventoryResolver, error) { + value := resolver.data.GetNodeInventory() + return resolver.root.wrapNodeInventory(value, true, nil) +} + func (resolver *nodeResolver) Notes(ctx context.Context) []string { value := resolver.data.GetNotes() return stringSlice(value) @@ -10366,6 +10402,329 @@ func (resolver *nodeComponentResolver) Version(ctx context.Context) string { return value } +type nodeInventoryResolver struct { + ctx context.Context + root *Resolver + data *storage.NodeInventory +} + +func (resolver *Resolver) wrapNodeInventory(value *storage.NodeInventory, ok bool, err error) (*nodeInventoryResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventoryResolver{root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventories(values []*storage.NodeInventory, err error) ([]*nodeInventoryResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventoryResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventoryResolver{root: resolver, data: v} + } + return output, nil +} + +func (resolver *Resolver) wrapNodeInventoryWithContext(ctx context.Context, value *storage.NodeInventory, ok bool, err error) (*nodeInventoryResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventoryResolver{ctx: ctx, root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventoriesWithContext(ctx context.Context, values []*storage.NodeInventory, err error) ([]*nodeInventoryResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventoryResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventoryResolver{ctx: ctx, root: resolver, data: v} + } + return output, nil +} + +func (resolver *nodeInventoryResolver) Components(ctx context.Context) (*nodeInventory_ComponentsResolver, error) { + value := resolver.data.GetComponents() + return resolver.root.wrapNodeInventory_Components(value, true, nil) +} + +func (resolver *nodeInventoryResolver) NodeName(ctx context.Context) string { + value := resolver.data.GetNodeName() + return value +} + +func (resolver *nodeInventoryResolver) Notes(ctx context.Context) []string { + value := resolver.data.GetNotes() + return stringSlice(value) +} + +func (resolver *nodeInventoryResolver) ScanTime(ctx context.Context) (*graphql.Time, error) { + value := resolver.data.GetScanTime() + return timestamp(value) +} + +type nodeInventory_ComponentsResolver struct { + ctx context.Context + root *Resolver + data *storage.NodeInventory_Components +} + +func (resolver *Resolver) wrapNodeInventory_Components(value *storage.NodeInventory_Components, ok bool, err error) (*nodeInventory_ComponentsResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_ComponentsResolver{root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_Componentses(values []*storage.NodeInventory_Components, err error) ([]*nodeInventory_ComponentsResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_ComponentsResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_ComponentsResolver{root: resolver, data: v} + } + return output, nil +} + +func (resolver *Resolver) wrapNodeInventory_ComponentsWithContext(ctx context.Context, value *storage.NodeInventory_Components, ok bool, err error) (*nodeInventory_ComponentsResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_ComponentsResolver{ctx: ctx, root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_ComponentsesWithContext(ctx context.Context, values []*storage.NodeInventory_Components, err error) ([]*nodeInventory_ComponentsResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_ComponentsResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_ComponentsResolver{ctx: ctx, root: resolver, data: v} + } + return output, nil +} + +func (resolver *nodeInventory_ComponentsResolver) Namespace(ctx context.Context) string { + value := resolver.data.GetNamespace() + return value +} + +func (resolver *nodeInventory_ComponentsResolver) RhelComponents(ctx context.Context) ([]*nodeInventory_Components_RHELComponentResolver, error) { + value := resolver.data.GetRhelComponents() + return resolver.root.wrapNodeInventory_Components_RHELComponents(value, nil) +} + +func (resolver *nodeInventory_ComponentsResolver) RhelContentSets(ctx context.Context) []string { + value := resolver.data.GetRhelContentSets() + return value +} + +type nodeInventory_Components_RHELComponentResolver struct { + ctx context.Context + root *Resolver + data *storage.NodeInventory_Components_RHELComponent +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent(value *storage.NodeInventory_Components_RHELComponent, ok bool, err error) (*nodeInventory_Components_RHELComponentResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_Components_RHELComponentResolver{root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponents(values []*storage.NodeInventory_Components_RHELComponent, err error) ([]*nodeInventory_Components_RHELComponentResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_Components_RHELComponentResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_Components_RHELComponentResolver{root: resolver, data: v} + } + return output, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponentWithContext(ctx context.Context, value *storage.NodeInventory_Components_RHELComponent, ok bool, err error) (*nodeInventory_Components_RHELComponentResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_Components_RHELComponentResolver{ctx: ctx, root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponentsWithContext(ctx context.Context, values []*storage.NodeInventory_Components_RHELComponent, err error) ([]*nodeInventory_Components_RHELComponentResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_Components_RHELComponentResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_Components_RHELComponentResolver{ctx: ctx, root: resolver, data: v} + } + return output, nil +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) AddedBy(ctx context.Context) string { + value := resolver.data.GetAddedBy() + return value +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) Arch(ctx context.Context) string { + value := resolver.data.GetArch() + return value +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) Executables(ctx context.Context) ([]*nodeInventory_Components_RHELComponent_ExecutableResolver, error) { + value := resolver.data.GetExecutables() + return resolver.root.wrapNodeInventory_Components_RHELComponent_Executables(value, nil) +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) Id(ctx context.Context) int32 { + value := resolver.data.GetId() + return int32(value) +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) Module(ctx context.Context) string { + value := resolver.data.GetModule() + return value +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) Name(ctx context.Context) string { + value := resolver.data.GetName() + return value +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) Namespace(ctx context.Context) string { + value := resolver.data.GetNamespace() + return value +} + +func (resolver *nodeInventory_Components_RHELComponentResolver) Version(ctx context.Context) string { + value := resolver.data.GetVersion() + return value +} + +type nodeInventory_Components_RHELComponent_ExecutableResolver struct { + ctx context.Context + root *Resolver + data *storage.NodeInventory_Components_RHELComponent_Executable +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_Executable(value *storage.NodeInventory_Components_RHELComponent_Executable, ok bool, err error) (*nodeInventory_Components_RHELComponent_ExecutableResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_Components_RHELComponent_ExecutableResolver{root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_Executables(values []*storage.NodeInventory_Components_RHELComponent_Executable, err error) ([]*nodeInventory_Components_RHELComponent_ExecutableResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_Components_RHELComponent_ExecutableResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_Components_RHELComponent_ExecutableResolver{root: resolver, data: v} + } + return output, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_ExecutableWithContext(ctx context.Context, value *storage.NodeInventory_Components_RHELComponent_Executable, ok bool, err error) (*nodeInventory_Components_RHELComponent_ExecutableResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_Components_RHELComponent_ExecutableResolver{ctx: ctx, root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_ExecutablesWithContext(ctx context.Context, values []*storage.NodeInventory_Components_RHELComponent_Executable, err error) ([]*nodeInventory_Components_RHELComponent_ExecutableResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_Components_RHELComponent_ExecutableResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_Components_RHELComponent_ExecutableResolver{ctx: ctx, root: resolver, data: v} + } + return output, nil +} + +func (resolver *nodeInventory_Components_RHELComponent_ExecutableResolver) Path(ctx context.Context) string { + value := resolver.data.GetPath() + return value +} + +func (resolver *nodeInventory_Components_RHELComponent_ExecutableResolver) RequiredFeatures(ctx context.Context) ([]*nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver, error) { + value := resolver.data.GetRequiredFeatures() + return resolver.root.wrapNodeInventory_Components_RHELComponent_Executable_FeatureNameVersions(value, nil) +} + +type nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver struct { + ctx context.Context + root *Resolver + data *storage.NodeInventory_Components_RHELComponent_Executable_FeatureNameVersion +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_Executable_FeatureNameVersion(value *storage.NodeInventory_Components_RHELComponent_Executable_FeatureNameVersion, ok bool, err error) (*nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver{root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_Executable_FeatureNameVersions(values []*storage.NodeInventory_Components_RHELComponent_Executable_FeatureNameVersion, err error) ([]*nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver{root: resolver, data: v} + } + return output, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_Executable_FeatureNameVersionWithContext(ctx context.Context, value *storage.NodeInventory_Components_RHELComponent_Executable_FeatureNameVersion, ok bool, err error) (*nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver, error) { + if !ok || err != nil || value == nil { + return nil, err + } + return &nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver{ctx: ctx, root: resolver, data: value}, nil +} + +func (resolver *Resolver) wrapNodeInventory_Components_RHELComponent_Executable_FeatureNameVersionsWithContext(ctx context.Context, values []*storage.NodeInventory_Components_RHELComponent_Executable_FeatureNameVersion, err error) ([]*nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver, error) { + if err != nil || len(values) == 0 { + return nil, err + } + output := make([]*nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver, len(values)) + for i, v := range values { + output[i] = &nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver{ctx: ctx, root: resolver, data: v} + } + return output, nil +} + +func (resolver *nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver) Name(ctx context.Context) string { + value := resolver.data.GetName() + return value +} + +func (resolver *nodeInventory_Components_RHELComponent_Executable_FeatureNameVersionResolver) Version(ctx context.Context) string { + value := resolver.data.GetVersion() + return value +} + +func toNodeInventory_Note(value *string) storage.NodeInventory_Note { + if value != nil { + return storage.NodeInventory_Note(storage.NodeInventory_Note_value[*value]) + } + return storage.NodeInventory_Note(0) +} + +func toNodeInventory_Notes(values *[]string) []storage.NodeInventory_Note { + if values == nil { + return nil + } + output := make([]storage.NodeInventory_Note, len(*values)) + for i, v := range *values { + output[i] = toNodeInventory_Note(&v) + } + return output +} + type nodeScanResolver struct { ctx context.Context root *Resolver diff --git a/central/node/datastore/dackbox/datastore/datastore_sac_test.go b/central/node/datastore/dackbox/datastore/datastore_sac_test.go index f86376e81563b..fcf84041c0646 100644 --- a/central/node/datastore/dackbox/datastore/datastore_sac_test.go +++ b/central/node/datastore/dackbox/datastore/datastore_sac_test.go @@ -262,9 +262,11 @@ func (s *nodeDatastoreSACSuite) TestGetNode() { s.True(found) s.NotNil(fetchedNode) - // Priority can have updated value, and we want to ignore it. - fetchedNode.Priority = s.testNodes[nodeID].Priority - s.Equal(*s.testNodes[nodeID], *fetchedNode) + if fetchedNode != nil { + // Priority can have updated value, and we want to ignore it. + fetchedNode.Priority = s.testNodes[nodeID].Priority + s.Equal(*s.testNodes[nodeID], *fetchedNode) + } } else { s.False(found) s.Nil(fetchedNode) diff --git a/central/sensor/service/pipeline/all/factory.go b/central/sensor/service/pipeline/all/factory.go index 090bdbf4462d2..c83dc0125d914 100644 --- a/central/sensor/service/pipeline/all/factory.go +++ b/central/sensor/service/pipeline/all/factory.go @@ -20,7 +20,6 @@ import ( "github.com/stackrox/rox/central/sensor/service/pipeline/networkflowupdate" "github.com/stackrox/rox/central/sensor/service/pipeline/networkpolicies" "github.com/stackrox/rox/central/sensor/service/pipeline/nodes" - "github.com/stackrox/rox/central/sensor/service/pipeline/nodescansv2" "github.com/stackrox/rox/central/sensor/service/pipeline/podevents" "github.com/stackrox/rox/central/sensor/service/pipeline/processindicators" "github.com/stackrox/rox/central/sensor/service/pipeline/reprocessing" @@ -65,9 +64,6 @@ func (s *factoryImpl) PipelineForCluster(ctx context.Context, clusterID string) alerts.GetPipeline(), auditlogstateupdate.GetPipeline(), } - if features.RHCOSNodeScanning.Enabled() { - pipelines = append(pipelines, nodescansv2.GetPipeline()) - } if features.ComplianceOperatorCheckResults.Enabled() { pipelines = append(pipelines, complianceoperatorresults.GetPipeline(), diff --git a/central/sensor/service/pipeline/nodescansv2/pipeline.go b/central/sensor/service/pipeline/nodescansv2/pipeline.go deleted file mode 100644 index a0fa0d1ebedaf..0000000000000 --- a/central/sensor/service/pipeline/nodescansv2/pipeline.go +++ /dev/null @@ -1,57 +0,0 @@ -package nodescansv2 - -import ( - "context" - - "github.com/pkg/errors" - countMetrics "github.com/stackrox/rox/central/metrics" - "github.com/stackrox/rox/central/sensor/service/common" - "github.com/stackrox/rox/central/sensor/service/pipeline" - "github.com/stackrox/rox/central/sensor/service/pipeline/reconciliation" - "github.com/stackrox/rox/generated/internalapi/central" - "github.com/stackrox/rox/pkg/logging" - "github.com/stackrox/rox/pkg/metrics" -) - -var ( - log = logging.LoggerForModule() -) - -// GetPipeline returns an instantiation of this particular pipeline -func GetPipeline() pipeline.Fragment { - return NewPipeline() -} - -// NewPipeline returns a new instance of Pipeline. -func NewPipeline() pipeline.Fragment { - return &pipelineImpl{} -} - -type pipelineImpl struct { -} - -func (p *pipelineImpl) Reconcile(ctx context.Context, clusterID string, storeMap *reconciliation.StoreMap) error { - return nil -} - -func (p *pipelineImpl) Match(msg *central.MsgFromSensor) bool { - return msg.GetEvent().GetNodeInventory() != nil -} - -// Run runs the pipeline template on the input and returns the output. -func (p *pipelineImpl) Run(ctx context.Context, clusterID string, msg *central.MsgFromSensor, _ common.MessageInjector) error { - defer countMetrics.IncrementResourceProcessedCounter(pipeline.ActionToOperation(msg.GetEvent().GetAction()), metrics.NodeInventory) - - event := msg.GetEvent() - nodeInventory := event.GetNodeInventory() - if nodeInventory == nil { - return errors.Errorf("unexpected resource type %T for node inventory", event.GetResource()) - } - - // TODO(ROX-12240, ROX-13053): Do something meaningful with the nodeInventory - log.Debugf("Central received NodeInventory: %+v", nodeInventory) - - return nil -} - -func (p *pipelineImpl) OnFinish(_ string) {} diff --git a/compliance/collection/nodeinventorizer/nodeinventory.go b/compliance/collection/nodeinventorizer/nodeinventory.go index 5233da0d717e7..5dc402cce4ca5 100644 --- a/compliance/collection/nodeinventorizer/nodeinventory.go +++ b/compliance/collection/nodeinventorizer/nodeinventory.go @@ -112,6 +112,9 @@ func convertAndDedupRHELComponents(rc *database.RHELv2Components) []*storage.Nod } func convertExecutables(exe []*scannerV1.Executable) []*storage.NodeInventory_Components_RHELComponent_Executable { + if exe == nil { + return nil + } arr := make([]*storage.NodeInventory_Components_RHELComponent_Executable, len(exe)) for i, executable := range exe { arr[i] = &storage.NodeInventory_Components_RHELComponent_Executable{ diff --git a/generated/api/v1/node_service.swagger.json b/generated/api/v1/node_service.swagger.json index ac65353990d0e..d86b4bc3f114f 100644 --- a/generated/api/v1/node_service.swagger.json +++ b/generated/api/v1/node_service.swagger.json @@ -122,6 +122,20 @@ ], "default": "UI_NONE" }, + "ComponentsRHELComponentExecutable": { + "type": "object", + "properties": { + "path": { + "type": "string" + }, + "requiredFeatures": { + "type": "array", + "items": { + "$ref": "#/definitions/RHELComponentExecutableFeatureNameVersion" + } + } + } + }, "EmbeddedVulnerabilityVulnerabilityType": { "type": "string", "enum": [ @@ -134,6 +148,50 @@ ], "default": "UNKNOWN_VULNERABILITY" }, + "NodeInventoryComponentsRHELComponent": { + "type": "object", + "properties": { + "id": { + "type": "string", + "format": "int64" + }, + "name": { + "type": "string" + }, + "namespace": { + "type": "string" + }, + "version": { + "type": "string" + }, + "arch": { + "type": "string" + }, + "module": { + "type": "string" + }, + "addedBy": { + "type": "string" + }, + "executables": { + "type": "array", + "items": { + "$ref": "#/definitions/ComponentsRHELComponentExecutable" + } + } + } + }, + "RHELComponentExecutableFeatureNameVersion": { + "type": "object", + "properties": { + "name": { + "type": "string" + }, + "version": { + "type": "string" + } + } + }, "protobufAny": { "type": "object", "properties": { @@ -618,6 +676,10 @@ "format": "date-time", "description": "Time we received an update from Kubernetes." }, + "nodeInventory": { + "$ref": "#/definitions/storageNodeInventory", + "description": "NodeInventory contains a list of components discovered on the node.\nIt will be in the DB in serialized form, but no dedicated field or table will be created thanks to \"sql:-\"." + }, "scan": { "$ref": "#/definitions/storageNodeScan" }, @@ -652,7 +714,60 @@ } } }, - "title": "Node represents information about a node in the cluster.\nnext available tag: 28" + "title": "Node represents information about a node in the cluster.\nnext available tag: 29" + }, + "storageNodeInventory": { + "type": "object", + "properties": { + "nodeName": { + "type": "string" + }, + "scanTime": { + "type": "string", + "format": "date-time" + }, + "components": { + "$ref": "#/definitions/storageNodeInventoryComponents", + "title": "Components represents a subset of the scannerV1.Components proto message containing only fields required for RHCOS node scanning.\nKeep scanner Components and NodeInventory_Components in sync to the degree defined by fuctions:\nfunc convertAndDedupRHELComponents (in pkg 'nodeinventorizer'), and the respective reverse convertion in pkg 'clairify'.\nWe are not using scannerV1.Components here for the following reasons:\n- to avoid conflicts between v1 and scannerV1 APIs when generating the code in central/graphql/resolvers/generated.go\n- to not expose scanner v1 API over stackrox graphql API" + }, + "notes": { + "type": "array", + "items": { + "$ref": "#/definitions/storageNodeInventoryNote" + }, + "title": "Note represents scannerV1.Note" + } + } + }, + "storageNodeInventoryComponents": { + "type": "object", + "properties": { + "namespace": { + "type": "string" + }, + "rhelComponents": { + "type": "array", + "items": { + "$ref": "#/definitions/NodeInventoryComponentsRHELComponent" + } + }, + "rhelContentSets": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "storageNodeInventoryNote": { + "type": "string", + "enum": [ + "OS_CVES_UNAVAILABLE", + "OS_CVES_STALE", + "LANGUAGE_CVES_UNAVAILABLE", + "CERTIFIED_RHEL_SCAN_UNAVAILABLE" + ], + "default": "OS_CVES_UNAVAILABLE" }, "storageNodeNote": { "type": "string", diff --git a/generated/internalapi/central/sensor_events.pb.go b/generated/internalapi/central/sensor_events.pb.go index eec7b95739321..a670222813354 100644 --- a/generated/internalapi/central/sensor_events.pb.go +++ b/generated/internalapi/central/sensor_events.pb.go @@ -323,7 +323,6 @@ type SensorEvent struct { // *SensorEvent_Namespace // *SensorEvent_Secret // *SensorEvent_Node - // *SensorEvent_NodeInventory // *SensorEvent_ServiceAccount // *SensorEvent_Role // *SensorEvent_Binding @@ -403,9 +402,6 @@ type SensorEvent_Secret struct { type SensorEvent_Node struct { Node *storage.Node `protobuf:"bytes,9,opt,name=node,proto3,oneof" json:"node,omitempty"` } -type SensorEvent_NodeInventory struct { - NodeInventory *storage.NodeInventory `protobuf:"bytes,25,opt,name=node_inventory,json=nodeInventory,proto3,oneof" json:"node_inventory,omitempty"` -} type SensorEvent_ServiceAccount struct { ServiceAccount *storage.ServiceAccount `protobuf:"bytes,14,opt,name=service_account,json=serviceAccount,proto3,oneof" json:"service_account,omitempty"` } @@ -518,17 +514,6 @@ func (m *SensorEvent_Node) Clone() isSensorEvent_Resource { cloned.Node = m.Node.Clone() return cloned } -func (*SensorEvent_NodeInventory) isSensorEvent_Resource() {} -func (m *SensorEvent_NodeInventory) Clone() isSensorEvent_Resource { - if m == nil { - return nil - } - cloned := new(SensorEvent_NodeInventory) - *cloned = *m - - cloned.NodeInventory = m.NodeInventory.Clone() - return cloned -} func (*SensorEvent_ServiceAccount) isSensorEvent_Resource() {} func (m *SensorEvent_ServiceAccount) Clone() isSensorEvent_Resource { if m == nil { @@ -765,13 +750,6 @@ func (m *SensorEvent) GetNode() *storage.Node { return nil } -func (m *SensorEvent) GetNodeInventory() *storage.NodeInventory { - if x, ok := m.GetResource().(*SensorEvent_NodeInventory); ok { - return x.NodeInventory - } - return nil -} - func (m *SensorEvent) GetServiceAccount() *storage.ServiceAccount { if x, ok := m.GetResource().(*SensorEvent_ServiceAccount); ok { return x.ServiceAccount @@ -886,7 +864,6 @@ func (*SensorEvent) XXX_OneofWrappers() []interface{} { (*SensorEvent_Namespace)(nil), (*SensorEvent_Secret)(nil), (*SensorEvent_Node)(nil), - (*SensorEvent_NodeInventory)(nil), (*SensorEvent_ServiceAccount)(nil), (*SensorEvent_Role)(nil), (*SensorEvent_Binding)(nil), @@ -2409,118 +2386,116 @@ func init() { } var fileDescriptor_6ea3082f8d4cc74c = []byte{ - // 1761 bytes of a gzipped FileDescriptorProto + // 1737 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0xbd, 0x73, 0x23, 0x49, - 0x15, 0x1f, 0x59, 0x96, 0x64, 0x3f, 0x7d, 0xd8, 0x6e, 0x5b, 0xf6, 0x58, 0xe7, 0xf3, 0xf9, 0xb4, - 0xc7, 0xae, 0xa1, 0x38, 0xbb, 0x6a, 0xf7, 0xa0, 0x80, 0x82, 0x05, 0xdb, 0x2b, 0x4a, 0xaa, 0x3d, - 0x7f, 0x54, 0xcb, 0xde, 0xaa, 0x3b, 0x82, 0xa9, 0xd9, 0xe9, 0xb6, 0x77, 0xf0, 0x68, 0x7a, 0xae, - 0x7b, 0xb4, 0x94, 0x02, 0x02, 0x22, 0x12, 0x02, 0x42, 0x32, 0x72, 0x12, 0x62, 0xfe, 0x03, 0x42, - 0xfe, 0x04, 0x6a, 0x49, 0x48, 0x89, 0x48, 0xa9, 0xfe, 0x98, 0x99, 0x96, 0x2c, 0xfb, 0x5c, 0x64, - 0xd3, 0xbf, 0xf7, 0x7b, 0x9f, 0xdd, 0xfd, 0x5e, 0x4b, 0xf0, 0x2c, 0x8c, 0x53, 0xca, 0x63, 0x3f, - 0xf2, 0x93, 0xf0, 0x30, 0xa0, 0x71, 0xca, 0xfd, 0xe8, 0x50, 0xd0, 0x58, 0x30, 0xee, 0xd1, 0xf7, - 0x34, 0x4e, 0xc5, 0x41, 0xc2, 0x59, 0xca, 0x50, 0xcd, 0x08, 0x3b, 0xdf, 0x9f, 0xd2, 0x60, 0xa3, - 0x24, 0x0a, 0xfd, 0x38, 0xa0, 0xd6, 0xa7, 0x47, 0xfc, 0xd4, 0xd7, 0x6a, 0x9d, 0x75, 0x91, 0x32, - 0xee, 0xdf, 0xd0, 0x43, 0x3f, 0xa2, 0x3c, 0x35, 0x60, 0x3b, 0x03, 0x83, 0x68, 0x2c, 0x52, 0xca, - 0x0d, 0xec, 0x66, 0x30, 0xa1, 0x49, 0xc4, 0x26, 0x23, 0x1a, 0x67, 0x0a, 0x7b, 0x99, 0x24, 0xf6, - 0x47, 0x54, 0x24, 0x7e, 0x40, 0xbd, 0x11, 0x4d, 0x7d, 0xcb, 0xcf, 0x4e, 0xce, 0xa0, 0xe9, 0x6f, - 0x18, 0xbf, 0xf5, 0x12, 0x16, 0x85, 0xc1, 0xc4, 0x48, 0x51, 0x2e, 0x65, 0x84, 0x1a, 0x6c, 0x23, - 0xc3, 0x04, 0x0d, 0x38, 0xcd, 0x3c, 0x7d, 0x5c, 0xa0, 0xfc, 0x7d, 0x18, 0x50, 0xcf, 0x0f, 0x02, - 0x36, 0xce, 0x03, 0xc9, 0x0d, 0xf1, 0xb7, 0x7e, 0x30, 0x6b, 0x68, 0xca, 0xe5, 0x27, 0x39, 0xca, - 0x59, 0x40, 0x85, 0xf0, 0xc2, 0x98, 0x84, 0x81, 0x9f, 0x32, 0x3e, 0x4b, 0x08, 0x47, 0xfe, 0x0d, - 0xf5, 0x64, 0x55, 0x6f, 0xb8, 0x9f, 0x86, 0x2c, 0x36, 0x84, 0x4f, 0xf3, 0x2a, 0x15, 0x95, 0x65, - 0x09, 0xe5, 0x85, 0x8d, 0xee, 0x4b, 0xd8, 0xc2, 0xd4, 0x38, 0x78, 0x95, 0x17, 0x0d, 0x87, 0xe2, - 0x16, 0x3d, 0x81, 0x66, 0x51, 0x46, 0x2f, 0x24, 0x6e, 0x69, 0xaf, 0xb4, 0xbf, 0x8c, 0x1b, 0x05, - 0x38, 0x20, 0xdd, 0xff, 0x94, 0xa0, 0x71, 0x24, 0x37, 0x06, 0x53, 0x31, 0x8e, 0x52, 0xf1, 0x28, - 0x2d, 0xf4, 0x14, 0xaa, 0x6a, 0x37, 0x85, 0xbb, 0xb0, 0x57, 0xde, 0xaf, 0x3f, 0x6f, 0x1d, 0x98, - 0x48, 0x0f, 0xb4, 0x2d, 0x23, 0x45, 0x9f, 0x43, 0x45, 0xa4, 0xfe, 0x0d, 0x75, 0xcb, 0x7b, 0xa5, - 0xfd, 0xd6, 0xf3, 0xad, 0x9c, 0xf6, 0x65, 0x78, 0x4d, 0x83, 0x49, 0x10, 0xd1, 0xa1, 0x14, 0x63, - 0xcd, 0x42, 0x5f, 0x40, 0x55, 0xb0, 0x31, 0x0f, 0xa8, 0xbb, 0xa8, 0xf8, 0x3b, 0x07, 0xe6, 0xc8, - 0x1d, 0xd8, 0x21, 0x1e, 0x0c, 0x15, 0x07, 0x1b, 0x6e, 0xf7, 0x10, 0xaa, 0x1a, 0x41, 0x1b, 0xb0, - 0xfa, 0xaa, 0x77, 0xf1, 0xe5, 0xf9, 0x57, 0xa7, 0xbd, 0xb3, 0x4b, 0xaf, 0xf7, 0xa6, 0x77, 0x76, - 0xb9, 0xea, 0xa0, 0x15, 0xa8, 0x1f, 0x5d, 0xbd, 0x1a, 0x64, 0x40, 0xa9, 0xfb, 0x35, 0x54, 0x2f, - 0xc3, 0x51, 0x18, 0xdf, 0xa0, 0x5d, 0x00, 0x12, 0x8a, 0xc4, 0x4f, 0x83, 0x77, 0x94, 0x9b, 0x4c, - 0x2d, 0x04, 0x75, 0x60, 0x89, 0x53, 0x13, 0xd2, 0x82, 0x92, 0xe6, 0x6b, 0xb4, 0x01, 0x95, 0xd8, - 0x8f, 0x99, 0x50, 0xb9, 0x95, 0xb1, 0x5e, 0x74, 0xff, 0xd6, 0x84, 0xfa, 0x50, 0x5d, 0x9e, 0x9e, - 0xbc, 0x3b, 0xa8, 0x05, 0x0b, 0x79, 0x0d, 0x17, 0x42, 0x82, 0x0e, 0xa1, 0xea, 0x07, 0x72, 0x8b, - 0x95, 0x3d, 0x59, 0x92, 0x2c, 0x45, 0x6c, 0x0c, 0x1f, 0x29, 0x31, 0x36, 0x34, 0xf4, 0x0c, 0xaa, - 0xa9, 0x0a, 0x56, 0xf9, 0xa9, 0x3f, 0x5f, 0xc9, 0x15, 0x74, 0x0e, 0xd8, 0x88, 0xd1, 0xcf, 0xa1, - 0x35, 0x7d, 0xf2, 0x55, 0x11, 0xeb, 0xcf, 0x37, 0xf3, 0xa2, 0x9f, 0x69, 0xf1, 0x85, 0x92, 0xf6, - 0x1d, 0xdc, 0x8c, 0x6d, 0x00, 0xfd, 0x00, 0xa0, 0xd8, 0x64, 0xb7, 0xa2, 0x94, 0xd7, 0x73, 0xe5, - 0xe2, 0x70, 0xf5, 0x1d, 0x6c, 0x11, 0xd1, 0x1e, 0x94, 0x13, 0x46, 0xdc, 0x75, 0xc5, 0x6f, 0xe4, - 0xfc, 0x0b, 0x46, 0xfa, 0x0e, 0x96, 0x22, 0xf4, 0x13, 0x58, 0xce, 0x6f, 0xad, 0x5b, 0x55, 0xbc, - 0x4e, 0x11, 0x54, 0x26, 0x39, 0x35, 0xd7, 0xb9, 0xef, 0xe0, 0x82, 0x8e, 0xbe, 0x0b, 0x55, 0x7d, - 0x3b, 0xdd, 0x9a, 0x49, 0x3f, 0x53, 0x1c, 0x2a, 0xb8, 0xef, 0x60, 0x43, 0x40, 0x4f, 0x60, 0x51, - 0x5e, 0x6e, 0x77, 0x59, 0x11, 0x9b, 0x85, 0x07, 0x46, 0x68, 0xdf, 0xc1, 0x4a, 0xa8, 0xaa, 0xc4, - 0x88, 0xbc, 0x6c, 0x72, 0x7b, 0x18, 0x9f, 0xb8, 0xdb, 0xb3, 0x55, 0x62, 0x84, 0x0e, 0x32, 0xa9, - 0xaa, 0x92, 0x0d, 0xa0, 0x63, 0x58, 0x99, 0x69, 0x0c, 0x6e, 0x4b, 0x59, 0xd8, 0xb2, 0x22, 0x53, - 0xf2, 0x23, 0x2d, 0xee, 0x3b, 0xb8, 0x25, 0xa6, 0x10, 0xf4, 0x14, 0x16, 0x39, 0x8b, 0xa8, 0xbb, - 0xa2, 0x14, 0x57, 0x73, 0xc5, 0xd7, 0x3f, 0x12, 0x98, 0x45, 0x2a, 0x58, 0x29, 0x47, 0x2f, 0xa0, - 0xf6, 0x56, 0x36, 0x8d, 0xf8, 0xc6, 0x5d, 0x9d, 0xf1, 0x61, 0xa8, 0xc7, 0x5a, 0xdc, 0x77, 0x70, - 0xc6, 0x44, 0x7d, 0x58, 0xbb, 0xd3, 0x70, 0xdc, 0x25, 0xa5, 0xbe, 0x5d, 0xec, 0x8e, 0x66, 0x0c, - 0x32, 0x42, 0xdf, 0xc1, 0xab, 0xc9, 0x0c, 0x66, 0x2c, 0xbd, 0x0f, 0x09, 0xe5, 0x79, 0xb3, 0x75, - 0xe1, 0xae, 0x25, 0xc5, 0xb0, 0xb6, 0x6f, 0x35, 0x99, 0xc1, 0xd0, 0x4b, 0xa8, 0x8a, 0x49, 0x1c, - 0x50, 0xe2, 0xd6, 0x95, 0xfa, 0x67, 0xf9, 0x21, 0xb6, 0xee, 0x4a, 0x7e, 0x03, 0xc4, 0x50, 0x71, - 0xd5, 0xd6, 0xaa, 0x2f, 0x74, 0x09, 0x6d, 0xc6, 0x83, 0x77, 0x54, 0xa4, 0xaa, 0xf7, 0x15, 0xd1, - 0x34, 0x94, 0xb9, 0x8f, 0xf3, 0x68, 0xce, 0x2d, 0x96, 0x15, 0xd1, 0x06, 0x9b, 0x83, 0xcb, 0xfc, - 0xee, 0x74, 0x5e, 0xb7, 0x39, 0x93, 0xdf, 0x40, 0x32, 0x06, 0x05, 0x41, 0xe6, 0x17, 0xce, 0x60, - 0xe8, 0x0a, 0x36, 0x78, 0xd6, 0x85, 0x3d, 0xeb, 0x12, 0xad, 0x29, 0x63, 0x7b, 0xd6, 0x1d, 0x9f, - 0xdb, 0xaa, 0xfb, 0x0e, 0x5e, 0xe7, 0x77, 0x45, 0xe8, 0xa7, 0xd0, 0x54, 0x8d, 0xd4, 0xe3, 0xba, - 0xf3, 0xb9, 0x48, 0xd9, 0x6b, 0xcf, 0x6d, 0x8b, 0x7d, 0x07, 0x37, 0x7c, 0xbb, 0x93, 0x5f, 0x43, - 0x67, 0xce, 0xdc, 0x30, 0xb6, 0xdc, 0x0d, 0x65, 0xea, 0x69, 0x9e, 0xe7, 0x49, 0x4e, 0x3d, 0x37, - 0xcc, 0x93, 0x77, 0x34, 0xb8, 0xd5, 0xc6, 0xfa, 0x0e, 0x76, 0x83, 0x3b, 0x04, 0x2d, 0x43, 0x04, - 0x3e, 0x9a, 0xe7, 0x27, 0xe1, 0xec, 0x3a, 0x8c, 0xa8, 0xdb, 0x56, 0x8e, 0xba, 0x0f, 0x38, 0xba, - 0xd0, 0xcc, 0xbe, 0x83, 0xb7, 0x83, 0xfb, 0x84, 0xe8, 0x57, 0xe0, 0xce, 0xcd, 0x66, 0x1c, 0x51, - 0x77, 0x53, 0xb9, 0xf8, 0xe4, 0x01, 0x17, 0x78, 0xac, 0xec, 0x6f, 0x06, 0x73, 0x25, 0xe8, 0xf7, - 0x25, 0xd8, 0x9f, 0x67, 0x5d, 0x04, 0x7e, 0xec, 0x09, 0x9a, 0xa6, 0x61, 0x7c, 0xe3, 0x65, 0x57, - 0x71, 0x4b, 0x79, 0xfb, 0xfc, 0x01, 0x6f, 0xc3, 0xc0, 0x8f, 0x87, 0x5a, 0xab, 0xb8, 0xa0, 0x9f, - 0x05, 0x8f, 0xe0, 0xdd, 0x97, 0xa6, 0x0c, 0xc4, 0x75, 0xbf, 0x35, 0x4d, 0x69, 0x70, 0x7e, 0x9a, - 0x52, 0xd2, 0x59, 0x83, 0x95, 0x99, 0x3b, 0x76, 0x0c, 0xc5, 0x84, 0xeb, 0xfe, 0xb7, 0x04, 0x6b, - 0xe6, 0x3e, 0xc6, 0xd7, 0x8c, 0x07, 0xd4, 0x1c, 0xc2, 0x3a, 0x2d, 0x96, 0x6a, 0x94, 0xb5, 0xac, - 0xfe, 0x6d, 0x51, 0xcd, 0xe4, 0xb2, 0xe9, 0xe8, 0x17, 0x53, 0x43, 0x65, 0x41, 0x65, 0xb0, 0x9b, - 0x9f, 0xdf, 0xe2, 0xac, 0x5b, 0x66, 0x66, 0xe6, 0xcb, 0x1b, 0x40, 0x01, 0x8b, 0x53, 0x3f, 0x8c, - 0x29, 0xf7, 0xc2, 0x58, 0xa4, 0x32, 0x2d, 0x33, 0x0c, 0xbf, 0x93, 0x5b, 0x3a, 0xc9, 0x28, 0x03, - 0xc3, 0x98, 0x36, 0xb8, 0x16, 0xcc, 0xca, 0xa7, 0x32, 0xff, 0x77, 0x09, 0xda, 0x73, 0x63, 0x79, - 0xdc, 0x73, 0xe8, 0x19, 0xac, 0x58, 0x24, 0x39, 0xbc, 0xcc, 0x6b, 0xa1, 0x55, 0xc0, 0x72, 0xce, - 0xcd, 0x10, 0xd3, 0x49, 0xa2, 0x13, 0x99, 0x22, 0x5e, 0x4e, 0x12, 0x8a, 0x76, 0xec, 0x91, 0xb9, - 0xa8, 0x28, 0xd6, 0x50, 0xdc, 0x86, 0x25, 0xdd, 0x17, 0x42, 0xa2, 0xe6, 0xf4, 0x32, 0xae, 0xa9, - 0xf5, 0x80, 0xa0, 0x4f, 0xa0, 0xae, 0xa7, 0xbf, 0x0e, 0xa3, 0xaa, 0x9f, 0x34, 0x1a, 0x92, 0x21, - 0x74, 0xff, 0x50, 0x82, 0x9d, 0x87, 0x8a, 0x85, 0xda, 0x50, 0x4d, 0x18, 0x91, 0xa6, 0x75, 0x0e, - 0x95, 0x84, 0x91, 0x01, 0x41, 0x57, 0xb0, 0x69, 0x85, 0x6e, 0x9f, 0x88, 0xf2, 0x63, 0x36, 0x15, - 0xb7, 0xc9, 0x3c, 0xb8, 0xfb, 0x97, 0x12, 0x34, 0x87, 0x01, 0xf7, 0x13, 0x7a, 0xc2, 0x46, 0x23, - 0x3f, 0x26, 0xe8, 0x23, 0x58, 0x16, 0x0a, 0x28, 0xaa, 0xbd, 0xa4, 0x81, 0x01, 0x41, 0x3f, 0x86, - 0x86, 0x48, 0x7d, 0x9e, 0x7a, 0x1a, 0x31, 0x07, 0x6a, 0xa3, 0x18, 0x27, 0x52, 0xa8, 0xed, 0xf5, - 0x1d, 0x5c, 0x17, 0xc5, 0x12, 0xfd, 0x10, 0xea, 0xb7, 0x61, 0x14, 0x65, 0x9a, 0x65, 0xf3, 0xbe, - 0xc9, 0x34, 0x5f, 0x87, 0x51, 0x94, 0x2b, 0xc2, 0x6d, 0xbe, 0x3a, 0x5e, 0x86, 0x5a, 0xa0, 0x43, - 0xeb, 0x0e, 0xa0, 0x6e, 0x39, 0x90, 0x9b, 0xf4, 0x8e, 0x89, 0x54, 0xed, 0x8b, 0x5b, 0xda, 0x2b, - 0xcb, 0x4d, 0xca, 0x01, 0x29, 0x95, 0xc5, 0x25, 0x3e, 0x27, 0xfa, 0x99, 0xbc, 0x8c, 0x0b, 0xa0, - 0xdb, 0x00, 0x28, 0x3c, 0x76, 0x7f, 0xb7, 0x00, 0x0d, 0xfd, 0x79, 0x95, 0x10, 0x3f, 0xa5, 0x0f, - 0x17, 0xe1, 0x35, 0xac, 0x59, 0x3d, 0x82, 0xd3, 0x74, 0xcc, 0x63, 0x53, 0x89, 0x9d, 0x83, 0x42, - 0x62, 0xf5, 0x07, 0xac, 0x38, 0x72, 0x74, 0x05, 0x33, 0x98, 0x7c, 0x10, 0x19, 0x4f, 0xaa, 0x58, - 0x94, 0x98, 0xca, 0x6c, 0x16, 0x35, 0x55, 0xe2, 0xa1, 0x96, 0xca, 0x07, 0x91, 0xb0, 0x01, 0x39, - 0xa4, 0x8c, 0x01, 0x59, 0x34, 0x4a, 0xcc, 0xb3, 0xb3, 0x3d, 0xa3, 0xff, 0x5a, 0x09, 0xe5, 0x90, - 0x12, 0xd6, 0xfa, 0x78, 0x09, 0xaa, 0x63, 0x95, 0x72, 0xf7, 0x8b, 0xec, 0x20, 0x64, 0x86, 0x9f, - 0x40, 0x93, 0x72, 0xae, 0xa6, 0xbd, 0x10, 0xf2, 0x47, 0x84, 0xb9, 0x7a, 0x0a, 0x3c, 0xd5, 0x58, - 0xf7, 0x45, 0x56, 0x38, 0x6d, 0xef, 0x71, 0x4a, 0x7f, 0x5d, 0x80, 0x4d, 0xfb, 0x31, 0x1c, 0x52, - 0x91, 0x9d, 0xbe, 0xb6, 0x7c, 0x6f, 0x7e, 0x93, 0x55, 0xbd, 0x8c, 0x2b, 0x82, 0x7e, 0x33, 0x20, - 0xe8, 0x08, 0x6a, 0x89, 0x3f, 0x89, 0x98, 0x4f, 0x4c, 0xa1, 0x9f, 0xe5, 0xe9, 0xcd, 0x37, 0x74, - 0x70, 0xa1, 0xe9, 0x38, 0xd3, 0xeb, 0xfc, 0x1a, 0x2a, 0x47, 0x49, 0x12, 0x4d, 0xd4, 0xed, 0x95, - 0x1f, 0xc5, 0xd6, 0xd6, 0xd4, 0x7a, 0x40, 0xd0, 0x2f, 0xa1, 0x31, 0x62, 0x24, 0xbc, 0x96, 0x0f, - 0xb0, 0xec, 0x37, 0x82, 0x3d, 0x3b, 0xa7, 0x5e, 0xf0, 0xa7, 0x16, 0x13, 0x4f, 0xe9, 0x75, 0xce, - 0xa1, 0x66, 0xfc, 0xa3, 0x9f, 0x41, 0x45, 0x59, 0x57, 0xae, 0xec, 0x8e, 0x79, 0x4f, 0xdc, 0x2a, - 0xc6, 0xbe, 0x83, 0xb5, 0xd6, 0x71, 0x05, 0xca, 0xc1, 0x88, 0x74, 0xff, 0x5c, 0x86, 0xad, 0x19, - 0x05, 0x4c, 0x45, 0xc2, 0x62, 0x41, 0xef, 0x2b, 0xd9, 0xf1, 0x6c, 0xc9, 0xf6, 0xef, 0x73, 0x9d, - 0x59, 0xba, 0x5b, 0x33, 0xf1, 0x88, 0x9a, 0x9d, 0xc3, 0xda, 0x38, 0x26, 0xcc, 0xfb, 0x3f, 0x0b, - 0xb7, 0x2a, 0x95, 0x6d, 0xa4, 0xf3, 0x29, 0x54, 0x7a, 0xf2, 0xb4, 0x20, 0x17, 0x6a, 0xd3, 0xa7, - 0x28, 0x5b, 0x76, 0xfe, 0x58, 0x2a, 0x0a, 0xfc, 0x12, 0x2a, 0xea, 0x70, 0x99, 0x02, 0x3f, 0xfd, - 0xd6, 0x2c, 0x95, 0x71, 0x59, 0x61, 0xa5, 0x26, 0xf5, 0xf5, 0x06, 0x2d, 0x3c, 0x52, 0x7f, 0xee, - 0x0e, 0x7d, 0xef, 0xb7, 0xd0, 0x9a, 0xfe, 0x05, 0x89, 0xb6, 0xa1, 0x7d, 0x75, 0x36, 0xec, 0x5d, - 0x7a, 0x47, 0x27, 0x97, 0x83, 0xf3, 0x33, 0x0f, 0xf7, 0x86, 0xe7, 0x57, 0xf8, 0xa4, 0xb7, 0xea, - 0xa0, 0x75, 0x58, 0x39, 0xc1, 0xbd, 0xa3, 0xcb, 0x5e, 0x01, 0x96, 0x24, 0x88, 0x7b, 0xa7, 0xe7, - 0x6f, 0x2c, 0x70, 0x41, 0x82, 0x57, 0x17, 0xaf, 0xa6, 0x98, 0x65, 0xb4, 0x06, 0xcd, 0xe1, 0x57, - 0x67, 0x27, 0x05, 0xb4, 0x78, 0xbc, 0xfd, 0xf7, 0x0f, 0xbb, 0xa5, 0x7f, 0x7c, 0xd8, 0x2d, 0xfd, - 0xf3, 0xc3, 0x6e, 0xe9, 0x4f, 0xff, 0xda, 0x75, 0xbe, 0xce, 0xfe, 0x2e, 0x7a, 0x5b, 0x55, 0xff, - 0x54, 0xbc, 0xf8, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x03, 0xc4, 0xbe, 0xbe, 0x69, 0x12, 0x00, - 0x00, + 0x15, 0x1f, 0x49, 0x96, 0x64, 0x3f, 0xc9, 0xb2, 0xdd, 0xb6, 0xec, 0xb1, 0xce, 0xe7, 0xf5, 0x69, + 0x8f, 0x5d, 0x43, 0x71, 0x76, 0xd5, 0xee, 0x41, 0x01, 0x05, 0x0b, 0xb6, 0x57, 0x94, 0x54, 0x7b, + 0xfe, 0xa8, 0x96, 0xbd, 0x55, 0x77, 0x04, 0x53, 0xb3, 0xd3, 0x6d, 0x7b, 0xf0, 0x68, 0x7a, 0xae, + 0x7b, 0xb4, 0x94, 0x03, 0x02, 0x22, 0x12, 0x02, 0x42, 0x32, 0x72, 0x12, 0xfe, 0x0d, 0x42, 0xfe, + 0x04, 0x6a, 0x49, 0x48, 0x89, 0x20, 0xa4, 0xfa, 0x63, 0x66, 0x5a, 0xb2, 0xec, 0x75, 0x91, 0x4d, + 0xff, 0xde, 0xef, 0x7d, 0x76, 0xf7, 0x7b, 0x2d, 0xc1, 0xf3, 0x30, 0x4e, 0x29, 0x8f, 0xfd, 0xc8, + 0x4f, 0xc2, 0xfd, 0x80, 0xc6, 0x29, 0xf7, 0xa3, 0x7d, 0x41, 0x63, 0xc1, 0xb8, 0x47, 0xdf, 0xd3, + 0x38, 0x15, 0x7b, 0x09, 0x67, 0x29, 0x43, 0x75, 0x23, 0xec, 0x7c, 0x7f, 0x42, 0x83, 0x8d, 0x92, + 0x28, 0xf4, 0xe3, 0x80, 0x5a, 0x9f, 0x1e, 0xf1, 0x53, 0x5f, 0xab, 0x75, 0x56, 0x45, 0xca, 0xb8, + 0x7f, 0x45, 0xf7, 0xfd, 0x88, 0xf2, 0xd4, 0x80, 0xed, 0x0c, 0x0c, 0xa2, 0xb1, 0x48, 0x29, 0x37, + 0xb0, 0x9b, 0xc1, 0x84, 0x26, 0x11, 0xbb, 0x1d, 0xd1, 0x38, 0x53, 0xd8, 0xc9, 0x24, 0xb1, 0x3f, + 0xa2, 0x22, 0xf1, 0x03, 0xea, 0x8d, 0x68, 0xea, 0x5b, 0x7e, 0xb6, 0x72, 0x06, 0x4d, 0x7f, 0xc3, + 0xf8, 0x8d, 0x97, 0xb0, 0x28, 0x0c, 0x6e, 0x8d, 0x14, 0xe5, 0x52, 0x46, 0xa8, 0xc1, 0xd6, 0x32, + 0x4c, 0xd0, 0x80, 0xd3, 0xcc, 0xd3, 0xa7, 0x05, 0xca, 0xdf, 0x87, 0x01, 0xf5, 0xfc, 0x20, 0x60, + 0xe3, 0x3c, 0x90, 0xdc, 0x10, 0x7f, 0xe7, 0x07, 0xd3, 0x86, 0x26, 0x5c, 0x3e, 0xc9, 0x51, 0xce, + 0x02, 0x2a, 0x84, 0x17, 0xc6, 0x24, 0x0c, 0xfc, 0x94, 0xf1, 0x69, 0x42, 0x38, 0xf2, 0xaf, 0xa8, + 0x27, 0xab, 0x7a, 0xc5, 0xfd, 0x34, 0x64, 0xb1, 0x21, 0x7c, 0x96, 0x57, 0xa9, 0xa8, 0x2c, 0x4b, + 0x28, 0x2f, 0x6c, 0x74, 0x5f, 0xc1, 0x06, 0xa6, 0xc6, 0xc1, 0xeb, 0xbc, 0x68, 0x38, 0x14, 0x37, + 0xe8, 0x29, 0x2c, 0x16, 0x65, 0xf4, 0x42, 0xe2, 0x96, 0x76, 0x4a, 0xbb, 0x0b, 0xb8, 0x59, 0x80, + 0x03, 0xd2, 0xfd, 0x77, 0x09, 0x9a, 0x07, 0x72, 0x63, 0x30, 0x15, 0xe3, 0x28, 0x15, 0x8f, 0xd2, + 0x42, 0xcf, 0xa0, 0xa6, 0x76, 0x53, 0xb8, 0xe5, 0x9d, 0xca, 0x6e, 0xe3, 0x45, 0x6b, 0xcf, 0x44, + 0xba, 0xa7, 0x6d, 0x19, 0x29, 0xfa, 0x02, 0xaa, 0x22, 0xf5, 0xaf, 0xa8, 0x5b, 0xd9, 0x29, 0xed, + 0xb6, 0x5e, 0x6c, 0xe4, 0xb4, 0xaf, 0xc2, 0x4b, 0x1a, 0xdc, 0x06, 0x11, 0x1d, 0x4a, 0x31, 0xd6, + 0x2c, 0xf4, 0x25, 0xd4, 0x04, 0x1b, 0xf3, 0x80, 0xba, 0x73, 0x8a, 0xbf, 0xb5, 0x67, 0x8e, 0xdc, + 0x9e, 0x1d, 0xe2, 0xde, 0x50, 0x71, 0xb0, 0xe1, 0x76, 0xf7, 0xa1, 0xa6, 0x11, 0xb4, 0x06, 0xcb, + 0xaf, 0x7b, 0x67, 0x5f, 0x9d, 0x7e, 0x7d, 0xdc, 0x3b, 0x39, 0xf7, 0x7a, 0x6f, 0x7b, 0x27, 0xe7, + 0xcb, 0x0e, 0x5a, 0x82, 0xc6, 0xc1, 0xc5, 0xeb, 0x41, 0x06, 0x94, 0xba, 0xdf, 0x40, 0xed, 0x3c, + 0x1c, 0x85, 0xf1, 0x15, 0xda, 0x06, 0x20, 0xa1, 0x48, 0xfc, 0x34, 0xb8, 0xa6, 0xdc, 0x64, 0x6a, + 0x21, 0xa8, 0x03, 0xf3, 0x9c, 0x9a, 0x90, 0xca, 0x4a, 0x9a, 0xaf, 0xd1, 0x1a, 0x54, 0x63, 0x3f, + 0x66, 0x42, 0xe5, 0x56, 0xc1, 0x7a, 0xd1, 0xfd, 0x6f, 0x13, 0x1a, 0x43, 0x75, 0x79, 0x7a, 0xf2, + 0xee, 0xa0, 0x16, 0x94, 0xf3, 0x1a, 0x96, 0x43, 0x82, 0xf6, 0xa1, 0xe6, 0x07, 0x72, 0x8b, 0x95, + 0x3d, 0x59, 0x92, 0x2c, 0x45, 0x6c, 0x0c, 0x1f, 0x28, 0x31, 0x36, 0x34, 0xf4, 0x1c, 0x6a, 0xa9, + 0x0a, 0x56, 0xf9, 0x69, 0xbc, 0x58, 0xca, 0x15, 0x74, 0x0e, 0xd8, 0x88, 0xd1, 0xcf, 0xa1, 0x35, + 0x79, 0xf2, 0x55, 0x11, 0x1b, 0x2f, 0xd6, 0xf3, 0xa2, 0x9f, 0x68, 0xf1, 0x99, 0x92, 0xf6, 0x1d, + 0xbc, 0x18, 0xdb, 0x00, 0xfa, 0x01, 0x40, 0xb1, 0xc9, 0x6e, 0x55, 0x29, 0xaf, 0xe6, 0xca, 0xc5, + 0xe1, 0xea, 0x3b, 0xd8, 0x22, 0xa2, 0x1d, 0xa8, 0x24, 0x8c, 0xb8, 0xab, 0x8a, 0xdf, 0xcc, 0xf9, + 0x67, 0x8c, 0xf4, 0x1d, 0x2c, 0x45, 0xe8, 0x27, 0xb0, 0x90, 0xdf, 0x5a, 0xb7, 0xa6, 0x78, 0x9d, + 0x22, 0xa8, 0x4c, 0x72, 0x6c, 0xae, 0x73, 0xdf, 0xc1, 0x05, 0x1d, 0x7d, 0x17, 0x6a, 0xfa, 0x76, + 0xba, 0x75, 0x93, 0x7e, 0xa6, 0x38, 0x54, 0x70, 0xdf, 0xc1, 0x86, 0x80, 0x9e, 0xc2, 0x9c, 0xbc, + 0xdc, 0xee, 0x82, 0x22, 0x2e, 0x16, 0x1e, 0x18, 0xa1, 0x7d, 0x07, 0x2b, 0x21, 0x3a, 0x84, 0xa5, + 0xa9, 0x7b, 0xed, 0xb6, 0x14, 0x7f, 0xc3, 0x32, 0xac, 0xe4, 0x07, 0x5a, 0xdc, 0x77, 0x70, 0x4b, + 0x4c, 0x20, 0xe8, 0x19, 0xcc, 0x71, 0x16, 0x51, 0x77, 0x49, 0x29, 0x2e, 0xe7, 0x8a, 0x6f, 0x7e, + 0x24, 0x30, 0x8b, 0x94, 0x2f, 0x29, 0x47, 0x2f, 0xa1, 0xfe, 0x4e, 0xde, 0xf9, 0xf8, 0xca, 0x5d, + 0x9e, 0xf2, 0x61, 0xa8, 0x87, 0x5a, 0xdc, 0x77, 0x70, 0xc6, 0x44, 0x7d, 0x58, 0xb9, 0xd3, 0x2f, + 0xdc, 0x79, 0xa5, 0xbe, 0x59, 0x14, 0x57, 0x33, 0x06, 0x19, 0xa1, 0xef, 0xe0, 0xe5, 0x64, 0x0a, + 0x33, 0x96, 0xde, 0x87, 0x84, 0xf2, 0xbc, 0x57, 0xba, 0x70, 0xd7, 0x92, 0x62, 0x58, 0xd5, 0x5f, + 0x4e, 0xa6, 0x30, 0xf4, 0x0a, 0x6a, 0xe2, 0x36, 0x0e, 0x28, 0x71, 0x1b, 0x4a, 0xfd, 0xf3, 0xfc, + 0x0c, 0x5a, 0x47, 0x3d, 0x3f, 0xc0, 0x62, 0xa8, 0xb8, 0x6a, 0x67, 0xd4, 0x17, 0x3a, 0x87, 0x36, + 0xe3, 0xc1, 0x35, 0x15, 0xa9, 0x6a, 0x5d, 0x45, 0x34, 0x4d, 0x65, 0xee, 0xd3, 0x3c, 0x9a, 0x53, + 0x8b, 0x65, 0x45, 0xb4, 0xc6, 0x66, 0xe0, 0x32, 0xbf, 0x3b, 0x8d, 0xd3, 0x5d, 0x9c, 0xca, 0x6f, + 0x20, 0x19, 0x83, 0x82, 0x20, 0xf3, 0x0b, 0xa7, 0x30, 0x74, 0x01, 0x6b, 0x3c, 0x6b, 0xa2, 0x9e, + 0x75, 0x07, 0x56, 0x94, 0xb1, 0x1d, 0xeb, 0x8a, 0xce, 0xec, 0xb4, 0x7d, 0x07, 0xaf, 0xf2, 0xbb, + 0x22, 0xf4, 0x53, 0x58, 0x54, 0x7d, 0xd0, 0xe3, 0xba, 0x71, 0xb9, 0x48, 0xd9, 0x6b, 0xcf, 0xec, + 0x6a, 0x7d, 0x07, 0x37, 0x7d, 0xbb, 0x11, 0x5f, 0x42, 0x67, 0x46, 0xdb, 0x37, 0xb6, 0xdc, 0x35, + 0x65, 0xea, 0x59, 0x9e, 0xe7, 0x51, 0x4e, 0x3d, 0x35, 0xcc, 0xa3, 0x6b, 0x1a, 0xdc, 0x68, 0x63, + 0x7d, 0x07, 0xbb, 0xc1, 0x1d, 0x82, 0x96, 0x21, 0x02, 0x9f, 0xcc, 0xf2, 0x93, 0x70, 0x76, 0x19, + 0x46, 0xd4, 0x6d, 0x2b, 0x47, 0xdd, 0x07, 0x1c, 0x9d, 0x69, 0x66, 0xdf, 0xc1, 0x9b, 0xc1, 0x7d, + 0x42, 0xf4, 0x2b, 0x70, 0x67, 0x66, 0x33, 0x8e, 0xa8, 0xbb, 0xae, 0x5c, 0x3c, 0x79, 0xc0, 0x05, + 0x1e, 0x2b, 0xfb, 0xeb, 0xc1, 0x4c, 0x09, 0xfa, 0x7d, 0x09, 0x76, 0x67, 0x59, 0x17, 0x81, 0x1f, + 0x7b, 0x82, 0xa6, 0x69, 0x18, 0x5f, 0x79, 0xd9, 0x55, 0xdc, 0x50, 0xde, 0xbe, 0x78, 0xc0, 0xdb, + 0x30, 0xf0, 0xe3, 0xa1, 0xd6, 0x2a, 0x2e, 0xe8, 0xe7, 0xc1, 0x23, 0x78, 0xf7, 0xa5, 0x29, 0x03, + 0x71, 0xdd, 0x8f, 0xa6, 0x29, 0x0d, 0xce, 0x4e, 0x53, 0x4a, 0x3a, 0x2b, 0xb0, 0x34, 0x75, 0xc7, + 0x0e, 0xa1, 0x18, 0x50, 0xdd, 0xff, 0x94, 0x60, 0xc5, 0xdc, 0xc7, 0xf8, 0x92, 0xf1, 0x80, 0x9a, + 0x43, 0xd8, 0xa0, 0xc5, 0x52, 0x4d, 0xa2, 0x96, 0xd5, 0x7e, 0x2d, 0xaa, 0x19, 0x3c, 0x36, 0x1d, + 0xfd, 0x62, 0x62, 0x26, 0x94, 0x55, 0x06, 0xdb, 0xf9, 0xf9, 0x2d, 0xce, 0xba, 0x65, 0x66, 0x6a, + 0x3c, 0xbc, 0x05, 0x14, 0xb0, 0x38, 0xf5, 0xc3, 0x98, 0x72, 0x2f, 0x8c, 0x45, 0x2a, 0xd3, 0x32, + 0xb3, 0xec, 0x3b, 0xb9, 0xa5, 0xa3, 0x8c, 0x32, 0x30, 0x8c, 0x49, 0x83, 0x2b, 0xc1, 0xb4, 0x7c, + 0x22, 0xf3, 0x7f, 0x95, 0xa0, 0x3d, 0x33, 0x96, 0xc7, 0xbd, 0x66, 0x9e, 0xc3, 0x92, 0x45, 0x92, + 0xb3, 0xc7, 0x0c, 0xfb, 0x56, 0x01, 0xcb, 0x31, 0x35, 0x45, 0x4c, 0x6f, 0x13, 0x9d, 0xc8, 0x04, + 0xf1, 0xfc, 0x36, 0xa1, 0x68, 0xcb, 0x9e, 0x78, 0x73, 0x8a, 0x62, 0xcd, 0xb4, 0x4d, 0x98, 0xd7, + 0x7d, 0x21, 0x24, 0x6a, 0xcc, 0x2e, 0xe0, 0xba, 0x5a, 0x0f, 0x08, 0x7a, 0x02, 0x0d, 0x3d, 0xbc, + 0x75, 0x18, 0x35, 0xfd, 0x22, 0xd1, 0x90, 0x0c, 0xa1, 0xfb, 0x87, 0x12, 0x6c, 0x3d, 0x54, 0x2c, + 0xd4, 0x86, 0x5a, 0xc2, 0x88, 0x34, 0xad, 0x73, 0xa8, 0x26, 0x8c, 0x0c, 0x08, 0xba, 0x80, 0x75, + 0x2b, 0x74, 0xfb, 0x44, 0x54, 0x1e, 0xb3, 0xa9, 0xb8, 0x4d, 0x66, 0xc1, 0xdd, 0xbf, 0x94, 0x60, + 0x71, 0x18, 0x70, 0x3f, 0xa1, 0x47, 0x6c, 0x34, 0xf2, 0x63, 0x82, 0x3e, 0x81, 0x05, 0xa1, 0x80, + 0xa2, 0xda, 0xf3, 0x1a, 0x18, 0x10, 0xf4, 0x63, 0x68, 0x8a, 0xd4, 0xe7, 0xa9, 0xa7, 0x11, 0x73, + 0xa0, 0xd6, 0x8a, 0x71, 0x22, 0x85, 0xda, 0x5e, 0xdf, 0xc1, 0x0d, 0x51, 0x2c, 0xd1, 0x0f, 0xa1, + 0x71, 0x13, 0x46, 0x51, 0xa6, 0x59, 0x31, 0xcf, 0x93, 0x4c, 0xf3, 0x4d, 0x18, 0x45, 0xb9, 0x22, + 0xdc, 0xe4, 0xab, 0xc3, 0x05, 0xa8, 0x07, 0x3a, 0xb4, 0xee, 0x00, 0x1a, 0x96, 0x03, 0xb9, 0x49, + 0xd7, 0x4c, 0xa4, 0x6a, 0x5f, 0xdc, 0xd2, 0x4e, 0x45, 0x6e, 0x52, 0x0e, 0x48, 0xa9, 0x2c, 0x2e, + 0xf1, 0x39, 0xd1, 0xaf, 0xdc, 0x05, 0x5c, 0x00, 0xdd, 0x26, 0x40, 0xe1, 0xb1, 0xfb, 0xbb, 0x32, + 0x34, 0xf5, 0xe7, 0x45, 0x42, 0xfc, 0x94, 0x3e, 0x5c, 0x84, 0x37, 0xb0, 0x62, 0xf5, 0x08, 0x4e, + 0xd3, 0x31, 0x8f, 0x4d, 0x25, 0xb6, 0xf6, 0x0a, 0x89, 0xd5, 0x1f, 0xb0, 0xe2, 0xc8, 0xd1, 0x15, + 0x4c, 0x61, 0xf2, 0xd5, 0x67, 0x3c, 0xa9, 0x62, 0x51, 0x62, 0x2a, 0xb3, 0x5e, 0xd4, 0x54, 0x89, + 0x87, 0x5a, 0x2a, 0x5f, 0x7d, 0xc2, 0x06, 0xe4, 0x90, 0x32, 0x06, 0x64, 0xd1, 0x28, 0x31, 0xaf, + 0xc6, 0xf6, 0x94, 0xfe, 0x1b, 0x25, 0x94, 0x43, 0x4a, 0x58, 0xeb, 0xc3, 0x79, 0xa8, 0x8d, 0x55, + 0xca, 0xdd, 0x2f, 0xb3, 0x83, 0x90, 0x19, 0x7e, 0x0a, 0x8b, 0x94, 0x73, 0x35, 0xed, 0x85, 0x90, + 0xbf, 0x01, 0xcc, 0xd5, 0x53, 0xe0, 0xb1, 0xc6, 0xba, 0x2f, 0xb3, 0xc2, 0x69, 0x7b, 0x8f, 0x53, + 0xfa, 0x6b, 0x19, 0xd6, 0xed, 0xb7, 0x6c, 0x48, 0x45, 0x76, 0xfa, 0xda, 0xf2, 0xb9, 0xf8, 0x6d, + 0x56, 0xf5, 0x0a, 0xae, 0x0a, 0xfa, 0xed, 0x80, 0xa0, 0x03, 0xa8, 0x27, 0xfe, 0x6d, 0xc4, 0x7c, + 0x62, 0x0a, 0xfd, 0x3c, 0x4f, 0x6f, 0xb6, 0xa1, 0xbd, 0x33, 0x4d, 0xc7, 0x99, 0x5e, 0xe7, 0xd7, + 0x50, 0x3d, 0x48, 0x92, 0xe8, 0x56, 0xdd, 0x5e, 0xf9, 0x51, 0x6c, 0x6d, 0x5d, 0xad, 0x07, 0x04, + 0xfd, 0x12, 0x9a, 0x23, 0x46, 0xc2, 0x4b, 0xf9, 0x00, 0xcb, 0x9e, 0xf8, 0xf6, 0xec, 0x9c, 0x78, + 0x80, 0x1f, 0x5b, 0x4c, 0x3c, 0xa1, 0xd7, 0x39, 0x85, 0xba, 0xf1, 0x8f, 0x7e, 0x06, 0x55, 0x65, + 0x5d, 0xb9, 0xb2, 0x3b, 0xe6, 0x3d, 0x71, 0xab, 0x18, 0xfb, 0x0e, 0xd6, 0x5a, 0x87, 0x55, 0xa8, + 0x04, 0x23, 0xd2, 0xfd, 0x73, 0x05, 0x36, 0xa6, 0x14, 0x30, 0x15, 0x09, 0x8b, 0x05, 0xbd, 0xaf, + 0x64, 0x87, 0xd3, 0x25, 0xdb, 0xbd, 0xcf, 0x75, 0x66, 0xe9, 0x6e, 0xcd, 0xc4, 0x23, 0x6a, 0x76, + 0x0a, 0x2b, 0xe3, 0x98, 0x30, 0xef, 0xff, 0x2c, 0xdc, 0xb2, 0x54, 0xb6, 0x91, 0xce, 0x67, 0x50, + 0xed, 0xc9, 0xd3, 0x82, 0x5c, 0xa8, 0x4f, 0x9e, 0xa2, 0x6c, 0xd9, 0xf9, 0x63, 0xa9, 0x28, 0xf0, + 0x2b, 0xa8, 0xaa, 0xc3, 0x65, 0x0a, 0xfc, 0xec, 0xa3, 0x59, 0x2a, 0xe3, 0xb2, 0xc2, 0x4a, 0x4d, + 0xea, 0xeb, 0x0d, 0x2a, 0x3f, 0x52, 0x7f, 0xe6, 0x0e, 0x7d, 0xef, 0xb7, 0xd0, 0x9a, 0xfc, 0x01, + 0x88, 0x36, 0xa1, 0x7d, 0x71, 0x32, 0xec, 0x9d, 0x7b, 0x07, 0x47, 0xe7, 0x83, 0xd3, 0x13, 0x0f, + 0xf7, 0x86, 0xa7, 0x17, 0xf8, 0xa8, 0xb7, 0xec, 0xa0, 0x55, 0x58, 0x3a, 0xc2, 0xbd, 0x83, 0xf3, + 0x5e, 0x01, 0x96, 0x24, 0x88, 0x7b, 0xc7, 0xa7, 0x6f, 0x2d, 0xb0, 0x2c, 0xc1, 0x8b, 0xb3, 0xd7, + 0x13, 0xcc, 0x0a, 0x5a, 0x81, 0xc5, 0xe1, 0xd7, 0x27, 0x47, 0x05, 0x34, 0x77, 0xb8, 0xf9, 0xb7, + 0x0f, 0xdb, 0xa5, 0xbf, 0x7f, 0xd8, 0x2e, 0xfd, 0xe3, 0xc3, 0x76, 0xe9, 0x4f, 0xff, 0xdc, 0x76, + 0xbe, 0xc9, 0xfe, 0xed, 0x79, 0x57, 0x53, 0x7f, 0x34, 0xbc, 0xfc, 0x5f, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xfd, 0xd9, 0x09, 0xe4, 0x28, 0x12, 0x00, 0x00, } func (m *ReprocessDeploymentRisk) Marshal() (dAtA []byte, err error) { @@ -3180,29 +3155,6 @@ func (m *SensorEvent_ComplianceOperatorScan) MarshalToSizedBuffer(dAtA []byte) ( } return len(dAtA) - i, nil } -func (m *SensorEvent_NodeInventory) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SensorEvent_NodeInventory) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.NodeInventory != nil { - { - size, err := m.NodeInventory.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintSensorEvents(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xca - } - return len(dAtA) - i, nil -} func (m *SensorEvent_ResourcesSynced) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -4464,18 +4416,6 @@ func (m *SensorEvent_ComplianceOperatorScan) Size() (n int) { } return n } -func (m *SensorEvent_NodeInventory) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.NodeInventory != nil { - l = m.NodeInventory.Size() - n += 2 + l + sovSensorEvents(uint64(l)) - } - return n -} func (m *SensorEvent_ResourcesSynced) Size() (n int) { if m == nil { return 0 @@ -6142,41 +6082,6 @@ func (m *SensorEvent) Unmarshal(dAtA []byte) error { } m.Resource = &SensorEvent_ComplianceOperatorScan{v} iNdEx = postIndex - case 25: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NodeInventory", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSensorEvents - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSensorEvents - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthSensorEvents - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &storage.NodeInventory{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Resource = &SensorEvent_NodeInventory{v} - iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipSensorEvents(dAtA[iNdEx:]) diff --git a/generated/storage/node.pb.go b/generated/storage/node.pb.go index dbef98c4b5281..64b13cf5e1a0e 100644 --- a/generated/storage/node.pb.go +++ b/generated/storage/node.pb.go @@ -107,7 +107,7 @@ func (NodeInventory_Note) EnumDescriptor() ([]byte, []int) { } // Node represents information about a node in the cluster. -// next available tag: 28 +// next available tag: 29 type Node struct { // A unique ID identifying this node. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" search:"Node ID,store" sql:"pk,type(uuid)"` @@ -138,7 +138,10 @@ type Node struct { LastUpdated *types.Timestamp `protobuf:"bytes,25,opt,name=last_updated,json=lastUpdated,proto3" json:"last_updated,omitempty" search:"Last Updated,hidden"` // Time we received an update from Kubernetes. K8SUpdated *types.Timestamp `protobuf:"bytes,26,opt,name=k8s_updated,json=k8sUpdated,proto3" json:"k8s_updated,omitempty" sensorhash:"ignore"` - Scan *NodeScan `protobuf:"bytes,18,opt,name=scan,proto3" json:"scan,omitempty" policy:"Node Scan"` + // NodeInventory contains a list of components discovered on the node. + // It will be in the DB in serialized form, but no dedicated field or table will be created thanks to "sql:-". + NodeInventory *NodeInventory `protobuf:"bytes,28,opt,name=node_inventory,json=nodeInventory,proto3" json:"node_inventory,omitempty" sql:"-"` + Scan *NodeScan `protobuf:"bytes,18,opt,name=scan,proto3" json:"scan,omitempty" policy:"Node Scan"` // Types that are valid to be assigned to SetComponents: // *Node_Components SetComponents isNode_SetComponents `protobuf_oneof:"set_components"` @@ -430,6 +433,13 @@ func (m *Node) GetK8SUpdated() *types.Timestamp { return nil } +func (m *Node) GetNodeInventory() *NodeInventory { + if m != nil { + return m.NodeInventory + } + return nil +} + func (m *Node) GetScan() *NodeScan { if m != nil { return m.Scan @@ -536,6 +546,7 @@ func (m *Node) Clone() *Node { cloned.ContainerRuntime = m.ContainerRuntime.Clone() cloned.LastUpdated = m.LastUpdated.Clone() cloned.K8SUpdated = m.K8SUpdated.Clone() + cloned.NodeInventory = m.NodeInventory.Clone() cloned.Scan = m.Scan.Clone() if m.SetComponents != nil { cloned.SetComponents = m.SetComponents.Clone() @@ -1289,114 +1300,115 @@ func init() { func init() { proto.RegisterFile("storage/node.proto", fileDescriptor_107f6eed651900c7) } var fileDescriptor_107f6eed651900c7 = []byte{ - // 1702 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xeb, 0x6e, 0xdb, 0xc8, - 0x15, 0xb6, 0x24, 0x5f, 0xa4, 0x23, 0x5f, 0xe4, 0x49, 0xe2, 0xd0, 0x72, 0x6c, 0x72, 0xb9, 0xdd, - 0x5d, 0x65, 0xd7, 0x91, 0x5b, 0x77, 0x81, 0x66, 0x0d, 0xc4, 0x80, 0x28, 0x2b, 0x89, 0xb2, 0x5e, - 0xc5, 0xa0, 0x64, 0xa3, 0x58, 0x14, 0x25, 0x68, 0x71, 0x6c, 0xb3, 0x92, 0x38, 0x5c, 0xce, 0x48, - 0xb0, 0xfa, 0x06, 0x7d, 0x83, 0x3e, 0x41, 0x1f, 0xa5, 0xe8, 0x8f, 0xfe, 0xe8, 0x13, 0x08, 0x8b, - 0xf4, 0x09, 0xaa, 0xbe, 0xc0, 0x62, 0x86, 0x1c, 0x8a, 0x94, 0x12, 0x04, 0x9b, 0x7f, 0xe4, 0xb9, - 0x7c, 0x73, 0xee, 0x73, 0x06, 0x10, 0x65, 0x24, 0xb0, 0x6f, 0xf1, 0x91, 0x47, 0x1c, 0x5c, 0xf5, - 0x03, 0xc2, 0x08, 0x5a, 0x8b, 0x68, 0x65, 0xf5, 0x96, 0x90, 0xdb, 0x3e, 0x3e, 0x12, 0xe4, 0xeb, - 0xe1, 0xcd, 0x11, 0x73, 0x07, 0x98, 0x32, 0x7b, 0xe0, 0x87, 0x92, 0x65, 0x55, 0x6a, 0x77, 0x89, - 0xc7, 0x6c, 0xd7, 0xc3, 0x81, 0x15, 0x0c, 0x3d, 0x2e, 0x15, 0x09, 0x3c, 0x94, 0x02, 0x9c, 0xcb, - 0x68, 0x44, 0xdd, 0x93, 0xd4, 0xd1, 0xb0, 0xef, 0xe1, 0xc0, 0xbe, 0x76, 0xfb, 0x2e, 0x1b, 0x4b, - 0x95, 0x5b, 0x72, 0x4b, 0xc4, 0xe7, 0x11, 0xff, 0x0a, 0xa9, 0xfa, 0x3f, 0xb7, 0x60, 0xb9, 0x45, - 0x1c, 0x8c, 0x4e, 0x21, 0xeb, 0x3a, 0x4a, 0x46, 0xcb, 0x54, 0x0a, 0x46, 0x75, 0x3a, 0x51, 0xbf, - 0xa6, 0xd8, 0x0e, 0xba, 0x77, 0x27, 0x3a, 0xe7, 0x6a, 0xcd, 0xb3, 0x43, 0x8e, 0x8d, 0x75, 0x8d, - 0xfe, 0xd4, 0x3f, 0xd1, 0xfd, 0xde, 0x21, 0x1b, 0xfb, 0xb8, 0x32, 0x1c, 0xba, 0xce, 0x53, 0xdd, - 0xcc, 0xba, 0x0e, 0xfa, 0x06, 0x96, 0x3d, 0x7b, 0x80, 0x95, 0xac, 0x40, 0x78, 0x3c, 0x9d, 0xa8, - 0x0f, 0x92, 0x08, 0x91, 0xba, 0x29, 0x84, 0xd0, 0x97, 0xb0, 0x1a, 0x1a, 0xae, 0xe4, 0xb4, 0x5c, - 0xa5, 0x78, 0xbc, 0x59, 0x8d, 0x2c, 0xaf, 0x76, 0x38, 0xd9, 0x8c, 0xb8, 0x68, 0x00, 0xd0, 0xed, - 0x0f, 0x29, 0xc3, 0x81, 0xe5, 0x3a, 0xca, 0xb2, 0x80, 0x6e, 0x4d, 0x27, 0xea, 0x1b, 0x09, 0x5d, - 0x0f, 0xb9, 0xf3, 0xf6, 0xdd, 0xf4, 0x2a, 0x11, 0xe7, 0xc4, 0x75, 0x9e, 0x1e, 0x7a, 0xe4, 0xd9, - 0x4d, 0xef, 0x59, 0x97, 0x78, 0x94, 0x05, 0x1c, 0x38, 0x65, 0x7c, 0x21, 0x3a, 0xa1, 0xe9, 0xa0, - 0x17, 0xb0, 0x2e, 0x8f, 0x13, 0xbe, 0xac, 0x88, 0x03, 0xcb, 0xd3, 0x89, 0xba, 0x33, 0x77, 0xa0, - 0x74, 0xa7, 0x18, 0xc9, 0xb7, 0xb8, 0x57, 0x6f, 0x60, 0xb5, 0x6f, 0x5f, 0xe3, 0x3e, 0x55, 0x56, - 0x85, 0x57, 0xbb, 0xb1, 0x57, 0x3c, 0x02, 0xd5, 0x73, 0xc1, 0x6b, 0x78, 0x2c, 0x18, 0x2f, 0xc6, - 0x47, 0x13, 0x5c, 0xdd, 0x8c, 0x10, 0xd0, 0x9f, 0xa1, 0x68, 0x7b, 0x1e, 0x61, 0x36, 0x73, 0x89, - 0x47, 0x95, 0x35, 0x01, 0x78, 0x90, 0x06, 0xac, 0xcd, 0x04, 0x42, 0xd4, 0x27, 0xd3, 0x89, 0xaa, - 0xa4, 0x50, 0x67, 0x22, 0xba, 0x99, 0x04, 0x44, 0x3f, 0x42, 0xe1, 0x2f, 0xc4, 0xf5, 0xb0, 0x63, - 0xd9, 0x4c, 0xd9, 0xd0, 0x32, 0x95, 0xe2, 0x71, 0xb9, 0x1a, 0x96, 0x65, 0x55, 0x96, 0x65, 0xb5, - 0x23, 0xcb, 0xd2, 0xf8, 0x6c, 0x3a, 0x51, 0xf7, 0x53, 0xc8, 0x6f, 0x88, 0xeb, 0x69, 0x5c, 0x40, - 0x86, 0x22, 0x1f, 0xe2, 0xd5, 0x18, 0x3a, 0x86, 0x47, 0xae, 0xc7, 0x70, 0xe0, 0xd9, 0x7d, 0xcb, - 0xf5, 0x2d, 0xdb, 0x71, 0x02, 0x4c, 0x29, 0xa6, 0x4a, 0x5e, 0xcb, 0x55, 0x0a, 0xe6, 0x03, 0xc9, - 0x6c, 0xfa, 0x35, 0xc9, 0xe2, 0x3a, 0xf8, 0xfe, 0x7d, 0x3a, 0x85, 0x50, 0x47, 0x32, 0x93, 0x3a, - 0xa7, 0xb0, 0xbb, 0xd0, 0x1f, 0xd6, 0x08, 0x07, 0xd4, 0x25, 0x9e, 0x02, 0x22, 0x77, 0x59, 0x25, - 0x63, 0x3e, 0x8e, 0x85, 0xcc, 0x50, 0xe6, 0x2a, 0x14, 0x41, 0x6f, 0x60, 0x7b, 0x41, 0x5f, 0xd9, - 0x14, 0xb1, 0xd8, 0x8f, 0x23, 0x5d, 0x9f, 0x53, 0x6e, 0x7a, 0x37, 0xc4, 0x2c, 0xcd, 0x43, 0xa2, - 0x2f, 0x60, 0xb3, 0x87, 0x03, 0x0f, 0xf7, 0x63, 0x03, 0x8a, 0xdc, 0x00, 0x73, 0x23, 0xa4, 0xca, - 0x23, 0x9f, 0x42, 0x89, 0xf8, 0x38, 0xb0, 0x99, 0xeb, 0xdd, 0x5a, 0x74, 0x4c, 0x19, 0x1e, 0x28, - 0xdb, 0x42, 0x70, 0x2b, 0xa6, 0xb7, 0x05, 0x19, 0x9d, 0x42, 0x9e, 0x50, 0xcb, 0x1d, 0xd8, 0xb7, - 0x58, 0x59, 0x17, 0xce, 0x7c, 0x3e, 0x9d, 0xa8, 0xaa, 0x4c, 0xc2, 0x5b, 0x29, 0xae, 0x85, 0xf2, - 0x32, 0x0d, 0x6b, 0x84, 0x36, 0xb9, 0x0e, 0xfa, 0x0a, 0xb6, 0x7a, 0xc3, 0x6b, 0xdc, 0xc7, 0x2c, - 0x36, 0x69, 0x4b, 0x9c, 0xb4, 0x19, 0x91, 0xa5, 0x4d, 0x87, 0x80, 0x38, 0xc5, 0xf2, 0x03, 0x72, - 0x3f, 0x8e, 0x65, 0x4b, 0x42, 0xb6, 0xc4, 0x39, 0x17, 0x9c, 0x21, 0xa5, 0x2d, 0x58, 0xef, 0xdb, - 0x94, 0x59, 0x43, 0xdf, 0xb1, 0x19, 0x76, 0x94, 0xdd, 0x8f, 0xd6, 0x8e, 0x36, 0x9d, 0xa8, 0x4f, - 0xa4, 0xd9, 0xe7, 0x36, 0x65, 0xda, 0x65, 0xa8, 0x7b, 0x78, 0xe7, 0x3a, 0x0e, 0xe6, 0x95, 0xc9, - 0x11, 0x23, 0x22, 0xea, 0x40, 0xb1, 0xf7, 0x9c, 0xc6, 0xf8, 0xe5, 0x8f, 0xe2, 0x47, 0xbd, 0xe4, - 0x51, 0x12, 0xdc, 0xd9, 0xf4, 0xee, 0x44, 0x77, 0x6f, 0x3d, 0x11, 0x0a, 0xe8, 0x3d, 0xa7, 0x12, - 0xf5, 0x05, 0x2c, 0xd3, 0xae, 0xed, 0x29, 0x48, 0xc0, 0x6d, 0xa7, 0x1a, 0xa9, 0xdd, 0xb5, 0x3d, - 0x63, 0x67, 0x3a, 0x51, 0x91, 0x4f, 0xfa, 0x6e, 0x77, 0x1c, 0x55, 0x38, 0x27, 0xeb, 0xa6, 0x50, - 0x43, 0xdf, 0x03, 0x74, 0xc9, 0xc0, 0x27, 0x1e, 0xe6, 0x43, 0xeb, 0x81, 0x96, 0xa9, 0xac, 0x18, - 0x4f, 0xa7, 0x13, 0xf5, 0x8b, 0x78, 0x2e, 0x48, 0xae, 0x56, 0x27, 0x43, 0x8f, 0x85, 0xd9, 0x90, - 0x0e, 0xbe, 0x5e, 0x32, 0x13, 0xea, 0xe8, 0x3b, 0x58, 0xee, 0x8e, 0x30, 0x55, 0x1e, 0x0a, 0x98, - 0x54, 0x56, 0xeb, 0x57, 0x8d, 0xf7, 0x02, 0x64, 0x4c, 0xa1, 0x82, 0x2e, 0x60, 0xfd, 0xc6, 0xbd, - 0xb7, 0xaf, 0xfb, 0xd8, 0x12, 0x10, 0x8f, 0x04, 0xc4, 0x37, 0xd3, 0x89, 0xfa, 0x95, 0x84, 0x78, - 0x19, 0xf2, 0xb5, 0x0f, 0x41, 0x65, 0xcd, 0x62, 0x04, 0x51, 0xe7, 0x88, 0x06, 0xe4, 0xfd, 0xc0, - 0x25, 0x81, 0xcb, 0xc6, 0xca, 0x8e, 0x96, 0xa9, 0xe4, 0x8c, 0x2f, 0xa7, 0x13, 0x55, 0x4f, 0xf5, - 0xba, 0xe9, 0xd2, 0x9e, 0x76, 0x11, 0x49, 0xc5, 0x59, 0x8b, 0xf5, 0x90, 0x01, 0x10, 0xb8, 0xb4, - 0x67, 0xd1, 0x2e, 0x09, 0xb0, 0xf2, 0x58, 0xcb, 0x54, 0xb2, 0x69, 0xb7, 0x66, 0x28, 0xed, 0x6e, - 0xc2, 0x16, 0xb3, 0xc0, 0xd5, 0x04, 0x09, 0xbd, 0x80, 0x3c, 0x23, 0xbe, 0xd5, 0x1d, 0x51, 0xaa, - 0x28, 0x02, 0x21, 0x55, 0x37, 0x02, 0xa1, 0x43, 0x7c, 0xad, 0x7e, 0xd5, 0x6e, 0x47, 0xb5, 0xfe, - 0x3a, 0x67, 0xae, 0x31, 0xe2, 0xd7, 0x47, 0x94, 0xa2, 0x0a, 0xac, 0x78, 0x84, 0x61, 0xaa, 0xec, - 0x69, 0xb9, 0xca, 0xe6, 0x31, 0x4a, 0x4f, 0xca, 0x16, 0x61, 0xd8, 0x0c, 0x05, 0xca, 0xdf, 0x41, - 0x31, 0x31, 0x89, 0x51, 0x09, 0x72, 0x3d, 0x3c, 0x0e, 0x2f, 0x3e, 0x93, 0x7f, 0xa2, 0x87, 0xb0, - 0x32, 0xb2, 0xfb, 0xc3, 0xe8, 0x2a, 0x33, 0xc3, 0x9f, 0x93, 0xec, 0xf3, 0x4c, 0xf9, 0x14, 0x4a, - 0xf3, 0x33, 0xf7, 0xd7, 0xe8, 0xeb, 0xfb, 0xfc, 0xae, 0x65, 0x18, 0x3d, 0x82, 0xed, 0x1f, 0x9a, - 0xed, 0x76, 0xb3, 0xf5, 0xca, 0x6a, 0xd7, 0x6b, 0x2d, 0xeb, 0xac, 0xd6, 0xa9, 0x95, 0x96, 0x8c, - 0x12, 0x6c, 0x52, 0xcc, 0xac, 0x59, 0xa5, 0x18, 0x00, 0x79, 0x41, 0x19, 0x61, 0x6a, 0x6c, 0x40, - 0x91, 0x7f, 0x47, 0xb9, 0x33, 0x36, 0x61, 0x9d, 0xff, 0xca, 0x98, 0xe9, 0xff, 0xce, 0x42, 0x5e, - 0x16, 0x33, 0x9f, 0xee, 0xbc, 0x6c, 0x2d, 0x31, 0xd1, 0x32, 0x9f, 0x30, 0xdd, 0x39, 0x4a, 0x7a, - 0xba, 0x73, 0x3c, 0x4e, 0x78, 0xef, 0x08, 0xcb, 0xbd, 0x7f, 0x84, 0xbd, 0x4d, 0x75, 0x4d, 0x56, - 0xdc, 0x61, 0x7a, 0x9c, 0x99, 0xc6, 0xe0, 0x1a, 0x3b, 0x0e, 0x76, 0xa4, 0xd5, 0x71, 0x0b, 0x19, - 0xc5, 0xe9, 0x44, 0x5d, 0x13, 0x17, 0xf9, 0x33, 0x3d, 0xd5, 0x39, 0x87, 0x32, 0xcb, 0xcb, 0x22, - 0xcb, 0x3b, 0x0b, 0x6d, 0x9c, 0xcc, 0xb4, 0x7e, 0x12, 0x85, 0xbb, 0x00, 0x2b, 0x97, 0xad, 0x76, - 0xa3, 0x53, 0x5a, 0x42, 0x5b, 0x50, 0xbc, 0x6c, 0xb5, 0x2f, 0x2f, 0x2e, 0xde, 0x9a, 0x9d, 0xc6, - 0x59, 0x29, 0x83, 0x76, 0x00, 0x7d, 0xdf, 0x30, 0x5b, 0x8d, 0x73, 0x2b, 0x49, 0xcf, 0xea, 0x7f, - 0xcb, 0xc3, 0x06, 0x07, 0x6d, 0x7a, 0x23, 0xec, 0x31, 0x12, 0x8c, 0xd1, 0x1e, 0x14, 0xf8, 0x2e, - 0x17, 0x6e, 0x06, 0x61, 0xba, 0xf3, 0x9c, 0x20, 0xae, 0xfe, 0x3f, 0x24, 0x03, 0x9e, 0xfd, 0x58, - 0xc0, 0x13, 0xd1, 0x6c, 0xa5, 0x42, 0x94, 0x13, 0x9a, 0x9f, 0xa5, 0xdc, 0x8a, 0x2d, 0xa8, 0xd6, - 0x67, 0x85, 0xf1, 0xc1, 0x08, 0xfd, 0x2e, 0x1d, 0xa1, 0xbd, 0x0f, 0x40, 0x25, 0x1b, 0xe2, 0x1f, - 0x2b, 0x00, 0x33, 0x68, 0xf4, 0x04, 0x0a, 0xdc, 0x45, 0xea, 0xdb, 0x5d, 0xe9, 0xe7, 0x8c, 0x80, - 0xfe, 0x08, 0x5b, 0xc1, 0x1d, 0xee, 0x5b, 0x0b, 0x79, 0x3d, 0xfa, 0xa8, 0xd1, 0x55, 0xf3, 0x75, - 0xe3, 0x3c, 0xfe, 0x35, 0x37, 0x39, 0x4e, 0xe2, 0xdc, 0xaf, 0x61, 0x3b, 0x42, 0xf6, 0x18, 0xf6, - 0x98, 0x45, 0x71, 0xb4, 0x1e, 0x16, 0xcc, 0xad, 0x50, 0x54, 0xd0, 0xdb, 0x98, 0xd1, 0xf2, 0xff, - 0x73, 0xb0, 0x91, 0x42, 0x43, 0x9b, 0xf1, 0xfa, 0x9a, 0x13, 0xeb, 0x28, 0x4a, 0xae, 0xa3, 0xd1, - 0xd6, 0x99, 0xf2, 0x2c, 0x37, 0xef, 0x99, 0x02, 0x6b, 0xf2, 0xee, 0x13, 0x8b, 0xa6, 0x29, 0x7f, - 0x39, 0x16, 0x6f, 0x8d, 0x70, 0x1d, 0x34, 0xc5, 0x37, 0xda, 0x81, 0xd5, 0x01, 0x71, 0x86, 0x7d, - 0xac, 0xac, 0x0a, 0x6a, 0xf4, 0x87, 0x76, 0x21, 0x6f, 0xf3, 0xa2, 0xb6, 0xae, 0xc7, 0xca, 0x5a, - 0x08, 0x23, 0xfe, 0x8d, 0x31, 0xfa, 0x13, 0x14, 0xf1, 0x3d, 0xee, 0x0e, 0x19, 0xef, 0xdf, 0x70, - 0x19, 0x2a, 0x1e, 0x9f, 0xfc, 0xca, 0xb0, 0x55, 0x1b, 0x31, 0x84, 0x99, 0x84, 0x2b, 0xff, 0x9c, - 0x01, 0x98, 0xf1, 0xb8, 0xcd, 0xbe, 0xcd, 0xee, 0xa2, 0x04, 0x8a, 0x6f, 0xf4, 0x57, 0xd8, 0x0e, - 0xf0, 0x4f, 0x43, 0x37, 0xc0, 0x8e, 0x75, 0x83, 0x6d, 0x36, 0x0c, 0xb0, 0xcc, 0xde, 0x0f, 0x9f, - 0x6e, 0x46, 0xf5, 0x65, 0x08, 0xc5, 0xfb, 0x20, 0x5a, 0x12, 0xcc, 0x92, 0x3c, 0x27, 0xe2, 0xd1, - 0xb2, 0x01, 0x68, 0x51, 0x2e, 0xce, 0x52, 0x26, 0x91, 0xa5, 0x44, 0x1e, 0xb2, 0xa9, 0x3c, 0xe8, - 0xa3, 0xa8, 0x9f, 0x1f, 0xc3, 0x83, 0xb7, 0x6d, 0xab, 0x7e, 0xd5, 0x68, 0x5b, 0x97, 0xad, 0xda, - 0x55, 0xad, 0x79, 0x5e, 0x33, 0xce, 0x1b, 0xa5, 0x25, 0xb4, 0x0d, 0x1b, 0x92, 0xd1, 0xee, 0xd4, - 0xce, 0x1b, 0xa5, 0x0c, 0xda, 0x87, 0xdd, 0xf3, 0x5a, 0xeb, 0xd5, 0x65, 0xed, 0x55, 0x63, 0x51, - 0x23, 0x8b, 0x3e, 0x07, 0xb5, 0xde, 0x30, 0x3b, 0xcd, 0x97, 0xcd, 0xc6, 0x99, 0xc5, 0x3d, 0x0c, - 0x07, 0x72, 0x52, 0x28, 0xa7, 0xff, 0x2f, 0x0b, 0xbb, 0x1f, 0x1c, 0x56, 0xe8, 0xb7, 0x49, 0x1f, - 0xd2, 0x2b, 0x78, 0x2c, 0x94, 0x7e, 0xfd, 0x9c, 0xce, 0x79, 0x68, 0xfc, 0x66, 0x3a, 0x51, 0xb5, - 0xc5, 0x4d, 0x22, 0x8a, 0x52, 0xbc, 0xd9, 0xc9, 0x7a, 0xfc, 0x16, 0x56, 0xf8, 0x03, 0x4f, 0x3e, - 0x9e, 0x0e, 0x16, 0x26, 0xea, 0x55, 0xf2, 0xf9, 0x67, 0x86, 0xc2, 0xe8, 0x0c, 0xb6, 0x92, 0xcf, - 0x42, 0x17, 0xcb, 0x57, 0x45, 0x39, 0x95, 0xfb, 0xb4, 0xee, 0xbc, 0x0a, 0x2a, 0x27, 0xd6, 0x85, - 0x65, 0xd1, 0x6d, 0xb3, 0x35, 0x60, 0x2f, 0x71, 0x85, 0xf3, 0x5e, 0xc9, 0xbe, 0x5e, 0x9a, 0x5d, - 0xd0, 0xfb, 0xa9, 0x1d, 0x81, 0x37, 0x4d, 0x36, 0x71, 0xfd, 0xcf, 0x5f, 0x67, 0xc6, 0xb7, 0xff, - 0x7a, 0x77, 0x90, 0xf9, 0xcf, 0xbb, 0x83, 0xcc, 0xcf, 0xef, 0x0e, 0x32, 0x7f, 0xff, 0xef, 0xc1, - 0x12, 0xec, 0xba, 0xa4, 0x4a, 0x99, 0xdd, 0xed, 0x05, 0xe4, 0x3e, 0x9c, 0xa9, 0xd2, 0xee, 0x1f, - 0xe5, 0xc3, 0xfa, 0x7a, 0x55, 0xd0, 0x7f, 0xff, 0x4b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe4, 0x46, - 0x50, 0x2d, 0x7e, 0x0f, 0x00, 0x00, + // 1723 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x57, 0xdd, 0x6e, 0xdb, 0xc8, + 0x15, 0xb6, 0x24, 0xff, 0x48, 0x47, 0xb6, 0x2c, 0x4f, 0x12, 0x87, 0x96, 0x63, 0x93, 0xcb, 0xed, + 0xee, 0x2a, 0xbb, 0x8e, 0xdc, 0xba, 0x0b, 0x34, 0x6b, 0x20, 0x06, 0x24, 0x59, 0x49, 0xe4, 0xf5, + 0x2a, 0x06, 0x25, 0x1b, 0xc5, 0xa2, 0x28, 0x41, 0x8b, 0x63, 0x9b, 0x95, 0xc4, 0xe1, 0x72, 0x46, + 0x82, 0xd5, 0x37, 0xe8, 0x6d, 0xaf, 0xfa, 0x04, 0x7d, 0x96, 0x5e, 0xf4, 0xa2, 0x4f, 0x20, 0x2c, + 0xd2, 0x27, 0xa8, 0xfa, 0x02, 0x8b, 0x19, 0x72, 0x28, 0x52, 0x72, 0x10, 0x6c, 0xee, 0xc8, 0xf3, + 0xf3, 0xcd, 0xf9, 0x9f, 0x33, 0x80, 0x28, 0x23, 0xbe, 0x75, 0x8b, 0x0f, 0x5d, 0x62, 0xe3, 0x8a, + 0xe7, 0x13, 0x46, 0xd0, 0x5a, 0x48, 0x2b, 0xa9, 0xb7, 0x84, 0xdc, 0xf6, 0xf1, 0xa1, 0x20, 0x5f, + 0x0f, 0x6f, 0x0e, 0x99, 0x33, 0xc0, 0x94, 0x59, 0x03, 0x2f, 0x90, 0x2c, 0xa9, 0x52, 0xbb, 0x4b, + 0x5c, 0x66, 0x39, 0x2e, 0xf6, 0x4d, 0x7f, 0xe8, 0x72, 0xa9, 0x50, 0xe0, 0xb1, 0x14, 0xe0, 0x5c, + 0x46, 0x43, 0xea, 0xae, 0xa4, 0x8e, 0x86, 0x7d, 0x17, 0xfb, 0xd6, 0xb5, 0xd3, 0x77, 0xd8, 0x58, + 0xaa, 0xdc, 0x92, 0x5b, 0x22, 0x3e, 0x0f, 0xf9, 0x57, 0x40, 0xd5, 0xff, 0x5e, 0x84, 0xe5, 0x16, + 0xb1, 0x31, 0x3a, 0x81, 0xb4, 0x63, 0x2b, 0x29, 0x2d, 0x55, 0xce, 0xd5, 0x2a, 0xd3, 0x89, 0xfa, + 0x35, 0xc5, 0x96, 0xdf, 0xbd, 0x3b, 0xd6, 0x39, 0x57, 0x6b, 0x9e, 0x1e, 0x70, 0x6c, 0xac, 0x6b, + 0xf4, 0xa7, 0xfe, 0xb1, 0xee, 0xf5, 0x0e, 0xd8, 0xd8, 0xc3, 0xe5, 0xe1, 0xd0, 0xb1, 0x9f, 0xeb, + 0x46, 0xda, 0xb1, 0xd1, 0x37, 0xb0, 0xec, 0x5a, 0x03, 0xac, 0xa4, 0x05, 0xc2, 0xd3, 0xe9, 0x44, + 0x7d, 0x14, 0x47, 0x08, 0xd5, 0x0d, 0x21, 0x84, 0xbe, 0x84, 0xd5, 0xc0, 0x70, 0x25, 0xa3, 0x65, + 0xca, 0xf9, 0xa3, 0x42, 0x25, 0xb4, 0xbc, 0xd2, 0xe1, 0x64, 0x23, 0xe4, 0xa2, 0x01, 0x40, 0xb7, + 0x3f, 0xa4, 0x0c, 0xfb, 0xa6, 0x63, 0x2b, 0xcb, 0x02, 0xba, 0x35, 0x9d, 0xa8, 0x67, 0x12, 0xba, + 0x1e, 0x70, 0xe7, 0xed, 0xbb, 0xe9, 0x95, 0x43, 0xce, 0xb1, 0x63, 0x3f, 0x3f, 0x70, 0xc9, 0x8b, + 0x9b, 0xde, 0x8b, 0x2e, 0x71, 0x29, 0xf3, 0x39, 0x70, 0xc2, 0xf8, 0x5c, 0x78, 0x42, 0xd3, 0x46, + 0xaf, 0x60, 0x5d, 0x1e, 0x27, 0x7c, 0x59, 0x11, 0x07, 0x96, 0xa6, 0x13, 0x75, 0x7b, 0xee, 0x40, + 0xe9, 0x4e, 0x3e, 0x94, 0x6f, 0x71, 0xaf, 0xce, 0x60, 0xb5, 0x6f, 0x5d, 0xe3, 0x3e, 0x55, 0x56, + 0x85, 0x57, 0x3b, 0x91, 0x57, 0x3c, 0x02, 0x95, 0x73, 0xc1, 0x6b, 0xb8, 0xcc, 0x1f, 0x2f, 0xc6, + 0x47, 0x13, 0x5c, 0xdd, 0x08, 0x11, 0xd0, 0x9f, 0x21, 0x6f, 0xb9, 0x2e, 0x61, 0x16, 0x73, 0x88, + 0x4b, 0x95, 0x35, 0x01, 0xb8, 0x9f, 0x04, 0xac, 0xce, 0x04, 0x02, 0xd4, 0x67, 0xd3, 0x89, 0xaa, + 0x24, 0x50, 0x67, 0x22, 0xba, 0x11, 0x07, 0x44, 0x3f, 0x42, 0xee, 0x2f, 0xc4, 0x71, 0xb1, 0x6d, + 0x5a, 0x4c, 0xd9, 0xd0, 0x52, 0xe5, 0xfc, 0x51, 0xa9, 0x12, 0x94, 0x65, 0x45, 0x96, 0x65, 0xa5, + 0x23, 0xcb, 0xb2, 0xf6, 0xd9, 0x74, 0xa2, 0xee, 0x25, 0x90, 0xcf, 0x88, 0xe3, 0x6a, 0x5c, 0x40, + 0x86, 0x22, 0x1b, 0xe0, 0x55, 0x19, 0x3a, 0x82, 0x27, 0x8e, 0xcb, 0xb0, 0xef, 0x5a, 0x7d, 0xd3, + 0xf1, 0x4c, 0xcb, 0xb6, 0x7d, 0x4c, 0x29, 0xa6, 0x4a, 0x56, 0xcb, 0x94, 0x73, 0xc6, 0x23, 0xc9, + 0x6c, 0x7a, 0x55, 0xc9, 0xe2, 0x3a, 0xf8, 0xfe, 0x21, 0x9d, 0x5c, 0xa0, 0x23, 0x99, 0x71, 0x9d, + 0x13, 0xd8, 0x59, 0xe8, 0x0f, 0x73, 0x84, 0x7d, 0xea, 0x10, 0x57, 0x01, 0x91, 0xbb, 0xb4, 0x92, + 0x32, 0x9e, 0x46, 0x42, 0x46, 0x20, 0x73, 0x15, 0x88, 0xa0, 0x33, 0xd8, 0x5a, 0xd0, 0x57, 0x0a, + 0x22, 0x16, 0x7b, 0x51, 0xa4, 0xeb, 0x73, 0xca, 0x4d, 0xf7, 0x86, 0x18, 0xc5, 0x79, 0x48, 0xf4, + 0x05, 0x14, 0x7a, 0xd8, 0x77, 0x71, 0x3f, 0x32, 0x20, 0xcf, 0x0d, 0x30, 0x36, 0x02, 0xaa, 0x3c, + 0xf2, 0x39, 0x14, 0x89, 0x87, 0x7d, 0x8b, 0x39, 0xee, 0xad, 0x49, 0xc7, 0x94, 0xe1, 0x81, 0xb2, + 0x25, 0x04, 0x37, 0x23, 0x7a, 0x5b, 0x90, 0xd1, 0x09, 0x64, 0x09, 0x35, 0x9d, 0x81, 0x75, 0x8b, + 0x95, 0x75, 0xe1, 0xcc, 0xe7, 0xd3, 0x89, 0xaa, 0xca, 0x24, 0xbc, 0x93, 0xe2, 0x5a, 0x20, 0x2f, + 0xd3, 0xb0, 0x46, 0x68, 0x93, 0xeb, 0xa0, 0xaf, 0x60, 0xb3, 0x37, 0xbc, 0xc6, 0x7d, 0xcc, 0x22, + 0x93, 0x36, 0xc5, 0x49, 0x85, 0x90, 0x2c, 0x6d, 0x3a, 0x00, 0xc4, 0x29, 0xa6, 0xe7, 0x93, 0xfb, + 0x71, 0x24, 0x5b, 0x14, 0xb2, 0x45, 0xce, 0xb9, 0xe0, 0x0c, 0x29, 0x6d, 0xc2, 0x7a, 0xdf, 0xa2, + 0xcc, 0x1c, 0x7a, 0xb6, 0xc5, 0xb0, 0xad, 0xec, 0x7c, 0xb4, 0x76, 0xb4, 0xe9, 0x44, 0x7d, 0x26, + 0xcd, 0x3e, 0xb7, 0x28, 0xd3, 0x2e, 0x03, 0xdd, 0x83, 0x3b, 0xc7, 0xb6, 0x31, 0xaf, 0x4c, 0x8e, + 0x18, 0x12, 0x51, 0x07, 0xf2, 0xbd, 0x97, 0x34, 0xc2, 0x2f, 0x7d, 0x14, 0x3f, 0xec, 0x25, 0x97, + 0x12, 0xff, 0xce, 0xa2, 0x77, 0xc7, 0xba, 0x73, 0xeb, 0x8a, 0x50, 0x40, 0xef, 0x25, 0x95, 0xa8, + 0x67, 0x50, 0xe0, 0x93, 0xd8, 0x74, 0xdc, 0x11, 0x76, 0x19, 0xf1, 0xc7, 0xca, 0x33, 0x01, 0xbc, + 0x9d, 0x68, 0xa9, 0xa6, 0xe4, 0xd6, 0xf2, 0xd3, 0x89, 0xba, 0x26, 0x66, 0xc9, 0x0b, 0xdd, 0xd8, + 0x70, 0xe3, 0x3c, 0xf4, 0x0a, 0x96, 0x69, 0xd7, 0x72, 0x15, 0x24, 0x10, 0xb6, 0x12, 0x08, 0xed, + 0xae, 0xe5, 0xd6, 0xb6, 0xa7, 0x13, 0x15, 0x79, 0xa4, 0xef, 0x74, 0xc7, 0x61, 0xb7, 0x70, 0xb2, + 0x6e, 0x08, 0x35, 0xf4, 0x3d, 0x40, 0x97, 0x0c, 0x3c, 0xe2, 0x62, 0x3e, 0x00, 0x1f, 0x69, 0xa9, + 0xf2, 0x4a, 0xed, 0xf9, 0x74, 0xa2, 0x7e, 0x11, 0xcd, 0x18, 0xc9, 0xd5, 0xea, 0x64, 0xe8, 0xb2, + 0x20, 0xb3, 0x32, 0x58, 0x6f, 0x97, 0x8c, 0x98, 0x3a, 0xfa, 0x0e, 0x96, 0xbb, 0x23, 0x4c, 0x95, + 0xc7, 0x02, 0x26, 0x51, 0x21, 0xf5, 0xab, 0xc6, 0x83, 0x00, 0x29, 0x43, 0xa8, 0xa0, 0x0b, 0x58, + 0xbf, 0x71, 0xee, 0xad, 0xeb, 0x3e, 0x36, 0x05, 0xc4, 0x13, 0x01, 0xf1, 0xcd, 0x74, 0xa2, 0x7e, + 0x25, 0x21, 0x5e, 0x07, 0x7c, 0xed, 0x43, 0x50, 0x69, 0x23, 0x1f, 0x42, 0xd4, 0x39, 0x62, 0x0d, + 0xb2, 0x9e, 0xef, 0x10, 0xdf, 0x61, 0x63, 0x65, 0x5b, 0x4b, 0x95, 0x33, 0xb5, 0x2f, 0xa7, 0x13, + 0x55, 0x4f, 0xcc, 0x0d, 0xc3, 0xa1, 0x3d, 0xed, 0x22, 0x94, 0x8a, 0x2a, 0x20, 0xd2, 0x43, 0x35, + 0x00, 0xdf, 0xa1, 0x3d, 0x93, 0x76, 0x89, 0x8f, 0x95, 0xa7, 0x5a, 0xaa, 0x9c, 0x4e, 0xba, 0x35, + 0x43, 0x69, 0x77, 0x63, 0xb6, 0x18, 0x39, 0xae, 0x26, 0x48, 0xe8, 0x15, 0x64, 0x19, 0xf1, 0xcc, + 0xee, 0x88, 0x52, 0x45, 0x11, 0x08, 0x89, 0x1a, 0x14, 0x08, 0x1d, 0xe2, 0x69, 0xf5, 0xab, 0x76, + 0x3b, 0xec, 0x9b, 0xb7, 0x19, 0x63, 0x8d, 0x11, 0xaf, 0x3e, 0xa2, 0x14, 0x95, 0x61, 0xc5, 0x25, + 0x0c, 0x53, 0x65, 0x57, 0xcb, 0x94, 0x0b, 0x47, 0x28, 0x39, 0x75, 0x5b, 0x84, 0x61, 0x23, 0x10, + 0x28, 0x7d, 0x07, 0xf9, 0xd8, 0x54, 0x47, 0x45, 0xc8, 0xf4, 0xf0, 0x38, 0xb8, 0x44, 0x0d, 0xfe, + 0x89, 0x1e, 0xc3, 0xca, 0xc8, 0xea, 0x0f, 0xc3, 0x6b, 0xd1, 0x08, 0x7e, 0x8e, 0xd3, 0x2f, 0x53, + 0xa5, 0x13, 0x28, 0xce, 0xcf, 0xef, 0x5f, 0xa3, 0xaf, 0xef, 0xf1, 0x7b, 0x9b, 0x61, 0xf4, 0x04, + 0xb6, 0x7e, 0x68, 0xb6, 0xdb, 0xcd, 0xd6, 0x1b, 0xb3, 0x5d, 0xaf, 0xb6, 0xcc, 0xd3, 0x6a, 0xa7, + 0x5a, 0x5c, 0xaa, 0x15, 0xa1, 0x40, 0x31, 0x33, 0x67, 0x95, 0x52, 0x03, 0xc8, 0x0a, 0xca, 0x08, + 0xd3, 0xda, 0x06, 0xe4, 0xf9, 0x77, 0x98, 0xbb, 0x5a, 0x01, 0xd6, 0xf9, 0xaf, 0x8c, 0x99, 0xfe, + 0xef, 0x34, 0x64, 0x65, 0x31, 0xf3, 0x9b, 0x82, 0x97, 0xad, 0x29, 0xa6, 0x63, 0xea, 0x13, 0x6e, + 0x0a, 0x8e, 0x92, 0xbc, 0x29, 0x38, 0x1e, 0x27, 0x3c, 0x38, 0x0e, 0x33, 0x0f, 0x8f, 0xc3, 0x77, + 0x89, 0xae, 0x49, 0x8b, 0xfb, 0x50, 0x8f, 0x32, 0xd3, 0x18, 0x5c, 0x63, 0xdb, 0xc6, 0xb6, 0xb4, + 0x3a, 0x6a, 0xa1, 0x64, 0x23, 0xc7, 0x3b, 0xe7, 0x40, 0x66, 0x79, 0x59, 0x64, 0x79, 0x7b, 0xa1, + 0x8d, 0xe3, 0x99, 0xd6, 0x8f, 0xc3, 0x70, 0xe7, 0x60, 0xe5, 0xb2, 0xd5, 0x6e, 0x74, 0x8a, 0x4b, + 0x68, 0x13, 0xf2, 0x97, 0xad, 0xf6, 0xe5, 0xc5, 0xc5, 0x3b, 0xa3, 0xd3, 0x38, 0x2d, 0xa6, 0xd0, + 0x36, 0xa0, 0xef, 0x1b, 0x46, 0xab, 0x71, 0x6e, 0xc6, 0xe9, 0x69, 0xfd, 0x6f, 0x59, 0xd8, 0x48, + 0x4c, 0x17, 0xb4, 0x0b, 0x39, 0x31, 0x8d, 0xc4, 0x96, 0x11, 0xa4, 0x3b, 0xcb, 0x09, 0x62, 0x8d, + 0xf8, 0x43, 0x3c, 0xe0, 0xe9, 0x8f, 0x05, 0x3c, 0x16, 0xcd, 0x56, 0x22, 0x44, 0x19, 0xa1, 0xf9, + 0xd9, 0xc3, 0xf3, 0xad, 0x52, 0x9f, 0x15, 0xc6, 0x07, 0x23, 0xf4, 0xbb, 0x64, 0x84, 0x76, 0x3f, + 0x00, 0x15, 0x6f, 0x88, 0x7f, 0xae, 0x00, 0xcc, 0xa0, 0xd1, 0x33, 0xc8, 0x71, 0x17, 0xa9, 0x67, + 0x75, 0xa5, 0x9f, 0x33, 0x02, 0xfa, 0x23, 0x6c, 0xfa, 0x77, 0xb8, 0x6f, 0x2e, 0xe4, 0xf5, 0xf0, + 0xa3, 0x46, 0x57, 0x8c, 0xb7, 0x8d, 0xf3, 0xe8, 0xd7, 0x28, 0x70, 0x9c, 0xd8, 0xb9, 0x5f, 0xc3, + 0x56, 0x88, 0xec, 0x32, 0xec, 0x32, 0x93, 0xe2, 0x70, 0xd5, 0xcc, 0x19, 0x9b, 0x81, 0xa8, 0xa0, + 0xb7, 0x31, 0xa3, 0xa5, 0xff, 0x67, 0x60, 0x23, 0x81, 0x86, 0x0a, 0xd1, 0x2a, 0x9c, 0x11, 0xab, + 0x2d, 0x8a, 0xaf, 0xb6, 0xe1, 0x06, 0x9b, 0xf0, 0x2c, 0x33, 0xef, 0x99, 0x02, 0x6b, 0xf2, 0x1e, + 0x15, 0x4b, 0xab, 0x21, 0x7f, 0x39, 0x16, 0x6f, 0x8d, 0x60, 0xb5, 0x34, 0xc4, 0x37, 0xda, 0x86, + 0xd5, 0x01, 0xb1, 0x87, 0x7d, 0xac, 0xac, 0x0a, 0x6a, 0xf8, 0x87, 0x76, 0x20, 0x6b, 0xf1, 0xa2, + 0x36, 0xaf, 0xc7, 0xca, 0x5a, 0x00, 0x23, 0xfe, 0x6b, 0x63, 0xf4, 0x27, 0xc8, 0xe3, 0x7b, 0xdc, + 0x1d, 0x32, 0xde, 0xbf, 0xc1, 0x62, 0x95, 0x3f, 0x3a, 0xfe, 0x95, 0x61, 0xab, 0x34, 0x22, 0x08, + 0x23, 0x0e, 0x57, 0xfa, 0x39, 0x05, 0x30, 0xe3, 0x71, 0x9b, 0x3d, 0x8b, 0xdd, 0x85, 0x09, 0x14, + 0xdf, 0xe8, 0xaf, 0xb0, 0xe5, 0xe3, 0x9f, 0x86, 0x8e, 0x8f, 0x6d, 0xf3, 0x06, 0x5b, 0x6c, 0xe8, + 0x63, 0x99, 0xbd, 0x1f, 0x3e, 0xdd, 0x8c, 0xca, 0xeb, 0x00, 0x8a, 0xf7, 0x41, 0xb8, 0x70, 0x18, + 0x45, 0x79, 0x4e, 0xc8, 0xa3, 0xa5, 0x1a, 0xa0, 0x45, 0xb9, 0x28, 0x4b, 0xa9, 0x58, 0x96, 0x62, + 0x79, 0x48, 0x27, 0xf2, 0xa0, 0x8f, 0xc2, 0x7e, 0x7e, 0x0a, 0x8f, 0xde, 0xb5, 0xcd, 0xfa, 0x55, + 0xa3, 0x6d, 0x5e, 0xb6, 0xaa, 0x57, 0xd5, 0xe6, 0x79, 0xb5, 0x76, 0xde, 0x28, 0x2e, 0xa1, 0x2d, + 0xd8, 0x90, 0x8c, 0x76, 0xa7, 0x7a, 0xde, 0x28, 0xa6, 0xd0, 0x1e, 0xec, 0x9c, 0x57, 0x5b, 0x6f, + 0x2e, 0xab, 0x6f, 0x1a, 0x8b, 0x1a, 0x69, 0xf4, 0x39, 0xa8, 0xf5, 0x86, 0xd1, 0x69, 0xbe, 0x6e, + 0x36, 0x4e, 0x4d, 0xee, 0x61, 0x30, 0x90, 0xe3, 0x42, 0x19, 0xfd, 0x7f, 0x69, 0xd8, 0xf9, 0xe0, + 0xb0, 0x42, 0xbf, 0x8d, 0xfb, 0x90, 0x5c, 0xe7, 0x23, 0xa1, 0xe4, 0x4b, 0xea, 0x64, 0xce, 0xc3, + 0xda, 0x6f, 0xa6, 0x13, 0x55, 0x5b, 0xdc, 0x24, 0xc2, 0x28, 0x45, 0x5b, 0xa2, 0xac, 0xc7, 0x6f, + 0x61, 0x85, 0x3f, 0x16, 0xe5, 0x43, 0x6c, 0x7f, 0x61, 0xa2, 0x5e, 0xc5, 0x9f, 0x92, 0x46, 0x20, + 0x8c, 0x4e, 0x61, 0x33, 0xfe, 0xc4, 0x74, 0xb0, 0x7c, 0xa1, 0x94, 0x12, 0xb9, 0x4f, 0xea, 0xce, + 0xab, 0xa0, 0x52, 0x6c, 0x5d, 0x58, 0x16, 0xdd, 0x36, 0x5b, 0x03, 0x76, 0x63, 0x57, 0x38, 0xef, + 0x95, 0xf4, 0xdb, 0xa5, 0xd9, 0x05, 0xbd, 0x97, 0xd8, 0x11, 0x78, 0xd3, 0xa4, 0x63, 0xd7, 0xff, + 0xfc, 0x75, 0x56, 0xfb, 0xf6, 0x5f, 0xef, 0xf7, 0x53, 0xff, 0x79, 0xbf, 0x9f, 0xfa, 0xf9, 0xfd, + 0x7e, 0xea, 0x1f, 0xff, 0xdd, 0x5f, 0x82, 0x1d, 0x87, 0x54, 0x28, 0xb3, 0xba, 0x3d, 0x9f, 0xdc, + 0x07, 0x33, 0x55, 0xda, 0xfd, 0xa3, 0x7c, 0xa4, 0x5f, 0xaf, 0x0a, 0xfa, 0xef, 0x7f, 0x09, 0x00, + 0x00, 0xff, 0xff, 0x78, 0xc7, 0xfd, 0xfa, 0xca, 0x0f, 0x00, 0x00, } func (m *Node) Marshal() (dAtA []byte, err error) { @@ -1423,21 +1435,35 @@ func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.NodeInventory != nil { + { + size, err := m.NodeInventory.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintNode(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0xe2 + } if len(m.Notes) > 0 { - dAtA2 := make([]byte, len(m.Notes)*10) - var j1 int + dAtA3 := make([]byte, len(m.Notes)*10) + var j2 int for _, num := range m.Notes { for num >= 1<<7 { - dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) + dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j1++ + j2++ } - dAtA2[j1] = uint8(num) - j1++ + dAtA3[j2] = uint8(num) + j2++ } - i -= j1 - copy(dAtA[i:], dAtA2[:j1]) - i = encodeVarintNode(dAtA, i, uint64(j1)) + i -= j2 + copy(dAtA[i:], dAtA3[:j2]) + i = encodeVarintNode(dAtA, i, uint64(j2)) i-- dAtA[i] = 0x1 i-- @@ -1789,20 +1815,20 @@ func (m *NodeScan) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Notes) > 0 { - dAtA9 := make([]byte, len(m.Notes)*10) - var j8 int + dAtA10 := make([]byte, len(m.Notes)*10) + var j9 int for _, num := range m.Notes { for num >= 1<<7 { - dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80) + dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j8++ + j9++ } - dAtA9[j8] = uint8(num) - j8++ + dAtA10[j9] = uint8(num) + j9++ } - i -= j8 - copy(dAtA[i:], dAtA9[:j8]) - i = encodeVarintNode(dAtA, i, uint64(j8)) + i -= j9 + copy(dAtA[i:], dAtA10[:j9]) + i = encodeVarintNode(dAtA, i, uint64(j9)) i-- dAtA[i] = 0x22 } @@ -1867,20 +1893,20 @@ func (m *NodeInventory) MarshalToSizedBuffer(dAtA []byte) (int, error) { copy(dAtA[i:], m.XXX_unrecognized) } if len(m.Notes) > 0 { - dAtA12 := make([]byte, len(m.Notes)*10) - var j11 int + dAtA13 := make([]byte, len(m.Notes)*10) + var j12 int for _, num := range m.Notes { for num >= 1<<7 { - dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80) + dAtA13[j12] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j11++ + j12++ } - dAtA12[j11] = uint8(num) - j11++ + dAtA13[j12] = uint8(num) + j12++ } - i -= j11 - copy(dAtA[i:], dAtA12[:j11]) - i = encodeVarintNode(dAtA, i, uint64(j11)) + i -= j12 + copy(dAtA[i:], dAtA13[:j12]) + i = encodeVarintNode(dAtA, i, uint64(j12)) i-- dAtA[i] = 0x22 } @@ -2390,6 +2416,10 @@ func (m *Node) Size() (n int) { } n += 2 + sovNode(uint64(l)) + l } + if m.NodeInventory != nil { + l = m.NodeInventory.Size() + n += 2 + l + sovNode(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -3719,6 +3749,42 @@ func (m *Node) Unmarshal(dAtA []byte) error { } else { return fmt.Errorf("proto: wrong wireType = %d for field Notes", wireType) } + case 28: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NodeInventory", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowNode + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthNode + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthNode + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.NodeInventory == nil { + m.NodeInventory = &NodeInventory{} + } + if err := m.NodeInventory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipNode(dAtA[iNdEx:]) diff --git a/proto/internalapi/central/sensor_events.proto b/proto/internalapi/central/sensor_events.proto index 24944e05ee195..83e3815ac053f 100644 --- a/proto/internalapi/central/sensor_events.proto +++ b/proto/internalapi/central/sensor_events.proto @@ -68,7 +68,6 @@ message SensorEvent { storage.NamespaceMetadata namespace = 6; storage.Secret secret = 7; storage.Node node = 9; - storage.NodeInventory node_inventory = 25; storage.ServiceAccount service_account = 14; storage.K8sRole role = 15; storage.K8sRoleBinding binding = 16; diff --git a/proto/storage/node.proto b/proto/storage/node.proto index 04a19863d5a9f..d61577eb48980 100644 --- a/proto/storage/node.proto +++ b/proto/storage/node.proto @@ -14,7 +14,7 @@ import "gogoproto/gogo.proto"; package storage; // Node represents information about a node in the cluster. -// next available tag: 28 +// next available tag: 29 message Node { // A unique ID identifying this node. string id = 1 [(gogoproto.moretags) = 'search:"Node ID,store" sql:"pk,type(uuid)"']; @@ -47,6 +47,9 @@ message Node { // Time we received an update from Kubernetes. google.protobuf.Timestamp k8s_updated = 26 [(gogoproto.moretags) = 'sensorhash:"ignore"']; + // NodeInventory contains a list of components discovered on the node. + // It will be in the DB in serialized form, but no dedicated field or table will be created thanks to "sql:-". + NodeInventory node_inventory = 28 [(gogoproto.moretags) = 'sql:"-"']; NodeScan scan = 18 [(gogoproto.moretags) = 'policy:"Node Scan"']; oneof set_components { int32 components = 19 [(gogoproto.moretags) = 'search:"Component Count,store,hidden"']; diff --git a/proto/storage/proto.lock b/proto/storage/proto.lock index 215f32e9d53a4..f204add2857de 100644 --- a/proto/storage/proto.lock +++ b/proto/storage/proto.lock @@ -10038,6 +10038,17 @@ } ] }, + { + "id": 28, + "name": "node_inventory", + "type": "NodeInventory", + "options": [ + { + "name": "(gogoproto.moretags)", + "value": "sql:\"-\"" + } + ] + }, { "id": 18, "name": "scan", @@ -10327,6 +10338,95 @@ } ] } + ], + "messages": [ + { + "name": "RHELComponent", + "fields": [ + { + "id": 1, + "name": "id", + "type": "int64" + }, + { + "id": 2, + "name": "name", + "type": "string" + }, + { + "id": 3, + "name": "namespace", + "type": "string" + }, + { + "id": 4, + "name": "version", + "type": "string" + }, + { + "id": 5, + "name": "arch", + "type": "string" + }, + { + "id": 6, + "name": "module", + "type": "string" + }, + { + "id": 7, + "name": "cpes", + "type": "string", + "is_repeated": true + }, + { + "id": 8, + "name": "added_by", + "type": "string" + }, + { + "id": 9, + "name": "executables", + "type": "Executable", + "is_repeated": true + } + ], + "messages": [ + { + "name": "Executable", + "fields": [ + { + "id": 1, + "name": "path", + "type": "string" + }, + { + "id": 2, + "name": "required_features", + "type": "FeatureNameVersion", + "is_repeated": true + } + ], + "messages": [ + { + "name": "FeatureNameVersion", + "fields": [ + { + "id": 1, + "name": "name", + "type": "string" + }, + { + "id": 2, + "name": "version", + "type": "string" + } + ] + } + ] + } + ] + } ] } ] @@ -14124,6 +14224,11 @@ "value": "true" } ] + }, + { + "id": 8, + "name": "traits", + "type": "Traits" } ], "maps": [ @@ -14175,6 +14280,11 @@ "id": 3, "name": "description", "type": "string" + }, + { + "id": 5, + "name": "traits", + "type": "Traits" } ], "maps": [ @@ -14222,6 +14332,11 @@ "id": 4, "name": "rules", "type": "Rules" + }, + { + "id": 5, + "name": "traits", + "type": "Traits" } ], "messages": [ @@ -14357,6 +14472,9 @@ { "path": "storage/labels.proto" }, + { + "path": "storage/traits.proto" + }, { "path": "gogoproto/gogo.proto" } @@ -17078,6 +17196,22 @@ "integer": 1 } ] + }, + { + "name": "Traits.Origin", + "enum_fields": [ + { + "name": "IMPERATIVE" + }, + { + "name": "DEFAULT", + "integer": 1 + }, + { + "name": "DECLARATIVE", + "integer": 2 + } + ] } ], "messages": [ @@ -17093,6 +17227,11 @@ "id": 2, "name": "visibility", "type": "Visibility" + }, + { + "id": 3, + "name": "origin", + "type": "Origin" } ] } diff --git a/sensor/common/compliance/node_inventory_handler_impl.go b/sensor/common/compliance/node_inventory_handler_impl.go index d059aec3f1fa7..c31abbe3875fc 100644 --- a/sensor/common/compliance/node_inventory_handler_impl.go +++ b/sensor/common/compliance/node_inventory_handler_impl.go @@ -1,11 +1,13 @@ package compliance import ( + "github.com/gogo/protobuf/types" "github.com/pkg/errors" "github.com/stackrox/rox/generated/internalapi/central" "github.com/stackrox/rox/generated/storage" "github.com/stackrox/rox/pkg/centralsensor" "github.com/stackrox/rox/pkg/concurrency" + "github.com/stackrox/rox/pkg/k8sutil" "github.com/stackrox/rox/pkg/sync" ) @@ -77,28 +79,63 @@ func (c *nodeInventoryHandlerImpl) run() <-chan *central.MsgFromSensor { c.stopper.Flow().StopWithError(errInputChanClosed) return } - // TODO(ROX-12943): Do something with the inventory, e.g., attach NodeID - c.sendInventory(toC, inventory) + c.handleNodeInventory(toC, inventory) } } }() return toC } -func (c *nodeInventoryHandlerImpl) sendInventory(toC chan *central.MsgFromSensor, inventory *storage.NodeInventory) { - if inventory == nil { +func (c *nodeInventoryHandlerImpl) handleNodeInventory(toC chan *central.MsgFromSensor, inventory *storage.NodeInventory) { + // TODO(ROX-12943): Replace fakeNode with proper solution for finding the node + node := c.fakeNode(inventory) + c.sendNode(toC, node) +} + +func (c *nodeInventoryHandlerImpl) sendNode(toC chan *central.MsgFromSensor, node *storage.Node) { + if node == nil { return } select { case <-c.stopper.Flow().StopRequested(): + return case toC <- ¢ral.MsgFromSensor{ Msg: ¢ral.MsgFromSensor_Event{ Event: ¢ral.SensorEvent{ - Resource: ¢ral.SensorEvent_NodeInventory{ - NodeInventory: inventory, + Id: node.GetId(), + Action: central.ResourceAction_CREATE_RESOURCE, // TODO(ROX-12943): find proper value to use here: create vs. update + Resource: ¢ral.SensorEvent_Node{ + Node: node, }, }, }, }: } } + +func (c *nodeInventoryHandlerImpl) fakeNode(inventory *storage.NodeInventory) *storage.Node { + if inventory == nil { + return nil + } + creation := inventory.ScanTime + return &storage.Node{ + // this is arbitrary selected UUID - we want to see only 1 fake node in the UI for each message from Compliance + Id: "bf5bf7d4-2d77-4194-9ab5-570848c55777", + Name: inventory.GetNodeName() + "-fake", + Taints: nil, + NodeInventory: inventory, + Labels: map[string]string{"fakeLabelsK": "fakeLabelsV"}, + Annotations: map[string]string{"fakeAnnotationsK": "fakeAnnotationsV"}, + JoinedAt: &types.Timestamp{Seconds: creation.Seconds, Nanos: creation.Nanos}, + InternalIpAddresses: []string{"192.168.255.254"}, + ExternalIpAddresses: []string{"10.10.255.254"}, + ContainerRuntime: k8sutil.ParseContainerRuntimeVersion("docker://20.10.18"), + ContainerRuntimeVersion: "docker://20.10.18", + KernelVersion: "99.19.16", + OperatingSystem: "Alpine Linux v3.16", + OsImage: "RedHat CoreOS v99.66.33", + KubeletVersion: "v1.25.0+k3s1", + KubeProxyVersion: "v1.25.0+k3s1", + K8SUpdated: types.TimestampNow(), + } +}