From 9aff980a38c8c61d9ff321b555bbfa12bd4faebd Mon Sep 17 00:00:00 2001 From: Jan Eitzinger Date: Fri, 24 Mar 2023 15:10:23 +0100 Subject: [PATCH] Add scope to Metric List. Add numberOfNodes. --- api/schema.graphqls | 1 + internal/graph/generated/generated.go | 163 ++++++++++++++++++++++++-- internal/graph/model/models_gen.go | 6 +- internal/graph/schema.resolvers.go | 9 ++ 4 files changed, 166 insertions(+), 13 deletions(-) diff --git a/api/schema.graphqls b/api/schema.graphqls index 41a50df..ae69249 100644 --- a/api/schema.graphqls +++ b/api/schema.graphqls @@ -41,6 +41,7 @@ type Cluster { type SubCluster { name: String! nodes: String! + numberOfNodes: Int! processorType: String! socketsPerNode: Int! coresPerSocket: Int! diff --git a/internal/graph/generated/generated.go b/internal/graph/generated/generated.go index 0a7592a..ea92255 100644 --- a/internal/graph/generated/generated.go +++ b/internal/graph/generated/generated.go @@ -42,6 +42,7 @@ type ResolverRoot interface { Job() JobResolver Mutation() MutationResolver Query() QueryResolver + SubCluster() SubClusterResolver } type DirectiveRoot struct { @@ -116,6 +117,7 @@ type ComplexityRoot struct { JobMetricWithName struct { Metric func(childComplexity int) int Name func(childComplexity int) int + Scope func(childComplexity int) int } JobResultList struct { @@ -220,6 +222,7 @@ type ComplexityRoot struct { MemoryBandwidth func(childComplexity int) int Name func(childComplexity int) int Nodes func(childComplexity int) int + NumberOfNodes func(childComplexity int) int ProcessorType func(childComplexity int) int SocketsPerNode func(childComplexity int) int ThreadsPerCore func(childComplexity int) int @@ -297,6 +300,9 @@ type QueryResolver interface { RooflineHeatmap(ctx context.Context, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) ([][]float64, error) NodeMetrics(ctx context.Context, cluster string, nodes []string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time) ([]*model.NodeMetrics, error) } +type SubClusterResolver interface { + NumberOfNodes(ctx context.Context, obj *schema.SubCluster) (int, error) +} type executableSchema struct { resolvers ResolverRoot @@ -614,6 +620,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.JobMetricWithName.Name(childComplexity), true + case "JobMetricWithName.scope": + if e.complexity.JobMetricWithName.Scope == nil { + break + } + + return e.complexity.JobMetricWithName.Scope(childComplexity), true + case "JobResultList.count": if e.complexity.JobResultList.Count == nil { break @@ -1144,6 +1157,13 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.SubCluster.Nodes(childComplexity), true + case "SubCluster.numberOfNodes": + if e.complexity.SubCluster.NumberOfNodes == nil { + break + } + + return e.complexity.SubCluster.NumberOfNodes(childComplexity), true + case "SubCluster.processorType": if e.complexity.SubCluster.ProcessorType == nil { break @@ -1444,6 +1464,7 @@ type Cluster { type SubCluster { name: String! nodes: String! + numberOfNodes: Int! processorType: String! socketsPerNode: Int! coresPerSocket: Int! @@ -1511,6 +1532,7 @@ type Resource { type JobMetricWithName { name: String! + scope: MetricScope! metric: JobMetric! } @@ -2509,6 +2531,8 @@ func (ec *executionContext) fieldContext_Cluster_subClusters(ctx context.Context return ec.fieldContext_SubCluster_name(ctx, field) case "nodes": return ec.fieldContext_SubCluster_nodes(ctx, field) + case "numberOfNodes": + return ec.fieldContext_SubCluster_numberOfNodes(ctx, field) case "processorType": return ec.fieldContext_SubCluster_processorType(ctx, field) case "socketsPerNode": @@ -4113,6 +4137,50 @@ func (ec *executionContext) fieldContext_JobMetricWithName_name(ctx context.Cont return fc, nil } +func (ec *executionContext) _JobMetricWithName_scope(ctx context.Context, field graphql.CollectedField, obj *model.JobMetricWithName) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_JobMetricWithName_scope(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Scope, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(schema.MetricScope) + fc.Result = res + return ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑbackendᚋpkgᚋschemaᚐMetricScope(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_JobMetricWithName_scope(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "JobMetricWithName", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type MetricScope does not have child fields") + }, + } + return fc, nil +} + func (ec *executionContext) _JobMetricWithName_metric(ctx context.Context, field graphql.CollectedField, obj *model.JobMetricWithName) (ret graphql.Marshaler) { fc, err := ec.fieldContext_JobMetricWithName_metric(ctx, field) if err != nil { @@ -5896,6 +5964,8 @@ func (ec *executionContext) fieldContext_NodeMetrics_metrics(ctx context.Context switch field.Name { case "name": return ec.fieldContext_JobMetricWithName_name(ctx, field) + case "scope": + return ec.fieldContext_JobMetricWithName_scope(ctx, field) case "metric": return ec.fieldContext_JobMetricWithName_metric(ctx, field) } @@ -6271,6 +6341,8 @@ func (ec *executionContext) fieldContext_Query_jobMetrics(ctx context.Context, f switch field.Name { case "name": return ec.fieldContext_JobMetricWithName_name(ctx, field) + case "scope": + return ec.fieldContext_JobMetricWithName_scope(ctx, field) case "metric": return ec.fieldContext_JobMetricWithName_metric(ctx, field) } @@ -7358,6 +7430,50 @@ func (ec *executionContext) fieldContext_SubCluster_nodes(ctx context.Context, f return fc, nil } +func (ec *executionContext) _SubCluster_numberOfNodes(ctx context.Context, field graphql.CollectedField, obj *schema.SubCluster) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_SubCluster_numberOfNodes(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.SubCluster().NumberOfNodes(rctx, obj) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(int) + fc.Result = res + return ec.marshalNInt2int(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_SubCluster_numberOfNodes(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "SubCluster", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Int does not have child fields") + }, + } + return fc, nil +} + func (ec *executionContext) _SubCluster_processorType(ctx context.Context, field graphql.CollectedField, obj *schema.SubCluster) (ret graphql.Marshaler) { fc, err := ec.fieldContext_SubCluster_processorType(ctx, field) if err != nil { @@ -11369,6 +11485,13 @@ func (ec *executionContext) _JobMetricWithName(ctx context.Context, sel ast.Sele out.Values[i] = ec._JobMetricWithName_name(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } + case "scope": + + out.Values[i] = ec._JobMetricWithName_scope(ctx, field, obj) + if out.Values[i] == graphql.Null { invalids++ } @@ -12263,70 +12386,90 @@ func (ec *executionContext) _SubCluster(ctx context.Context, sel ast.SelectionSe out.Values[i] = ec._SubCluster_name(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "nodes": out.Values[i] = ec._SubCluster_nodes(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } + case "numberOfNodes": + field := field + + innerFunc := func(ctx context.Context) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._SubCluster_numberOfNodes(ctx, field, obj) + if res == graphql.Null { + atomic.AddUint32(&invalids, 1) + } + return res + } + + out.Concurrently(i, func() graphql.Marshaler { + return innerFunc(ctx) + + }) case "processorType": out.Values[i] = ec._SubCluster_processorType(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "socketsPerNode": out.Values[i] = ec._SubCluster_socketsPerNode(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "coresPerSocket": out.Values[i] = ec._SubCluster_coresPerSocket(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "threadsPerCore": out.Values[i] = ec._SubCluster_threadsPerCore(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "flopRateScalar": out.Values[i] = ec._SubCluster_flopRateScalar(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "flopRateSimd": out.Values[i] = ec._SubCluster_flopRateSimd(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "memoryBandwidth": out.Values[i] = ec._SubCluster_memoryBandwidth(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } case "topology": out.Values[i] = ec._SubCluster_topology(ctx, field, obj) if out.Values[i] == graphql.Null { - invalids++ + atomic.AddUint32(&invalids, 1) } default: panic("unknown field " + strconv.Quote(field.Name)) diff --git a/internal/graph/model/models_gen.go b/internal/graph/model/models_gen.go index 03e0d46..edda844 100644 --- a/internal/graph/model/models_gen.go +++ b/internal/graph/model/models_gen.go @@ -58,9 +58,9 @@ type JobFilter struct { } type JobMetricWithName struct { - Name string `json:"name"` - Scope schema.MetricScope `json:"scope"` - Metric *schema.JobMetric `json:"metric"` + Name string `json:"name"` + Scope schema.MetricScope `json:"scope"` + Metric *schema.JobMetric `json:"metric"` } type JobResultList struct { diff --git a/internal/graph/schema.resolvers.go b/internal/graph/schema.resolvers.go index 718f331..9d25045 100644 --- a/internal/graph/schema.resolvers.go +++ b/internal/graph/schema.resolvers.go @@ -280,6 +280,11 @@ func (r *queryResolver) NodeMetrics(ctx context.Context, cluster string, nodes [ return nodeMetrics, nil } +// NumberOfNodes is the resolver for the numberOfNodes field. +func (r *subClusterResolver) NumberOfNodes(ctx context.Context, obj *schema.SubCluster) (int, error) { + panic(fmt.Errorf("not implemented: NumberOfNodes - numberOfNodes")) +} + // Cluster returns generated.ClusterResolver implementation. func (r *Resolver) Cluster() generated.ClusterResolver { return &clusterResolver{r} } @@ -292,7 +297,11 @@ func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResol // Query returns generated.QueryResolver implementation. func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} } +// SubCluster returns generated.SubClusterResolver implementation. +func (r *Resolver) SubCluster() generated.SubClusterResolver { return &subClusterResolver{r} } + type clusterResolver struct{ *Resolver } type jobResolver struct{ *Resolver } type mutationResolver struct{ *Resolver } type queryResolver struct{ *Resolver } +type subClusterResolver struct{ *Resolver }