cc-backend/graph/generated/generated.go

10542 lines
285 KiB
Go
Raw Normal View History

2021-03-31 08:50:53 +02:00
// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.
package generated
import (
"bytes"
"context"
"errors"
"strconv"
"sync"
"sync/atomic"
"time"
"github.com/99designs/gqlgen/graphql"
"github.com/99designs/gqlgen/graphql/introspection"
"github.com/ClusterCockpit/cc-jobarchive/graph/model"
2021-10-26 10:22:02 +02:00
"github.com/ClusterCockpit/cc-jobarchive/schema"
2021-03-31 08:50:53 +02:00
gqlparser "github.com/vektah/gqlparser/v2"
"github.com/vektah/gqlparser/v2/ast"
)
// region ************************** generated!.gotpl **************************
// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
return &executableSchema{
resolvers: cfg.Resolvers,
directives: cfg.Directives,
complexity: cfg.Complexity,
}
}
type Config struct {
Resolvers ResolverRoot
Directives DirectiveRoot
Complexity ComplexityRoot
}
type ResolverRoot interface {
2021-04-21 10:12:19 +02:00
Job() JobResolver
2021-05-21 09:30:15 +02:00
Mutation() MutationResolver
2021-03-31 08:50:53 +02:00
Query() QueryResolver
}
type DirectiveRoot struct {
}
type ComplexityRoot struct {
Accelerator struct {
ID func(childComplexity int) int
Model func(childComplexity int) int
Type func(childComplexity int) int
}
2021-04-22 15:00:54 +02:00
Cluster struct {
2021-12-17 15:49:22 +01:00
FilterRanges func(childComplexity int) int
MetricConfig func(childComplexity int) int
Name func(childComplexity int) int
Partitions func(childComplexity int) int
2021-04-22 15:00:54 +02:00
}
FilterRanges struct {
Duration func(childComplexity int) int
NumNodes func(childComplexity int) int
StartTime func(childComplexity int) int
}
2021-03-31 08:50:53 +02:00
HistoPoint struct {
Count func(childComplexity int) int
Value func(childComplexity int) int
}
IntRangeOutput struct {
From func(childComplexity int) int
To func(childComplexity int) int
}
2021-03-31 08:50:53 +02:00
Job struct {
2021-12-17 15:49:22 +01:00
ArrayJobId func(childComplexity int) int
Cluster func(childComplexity int) int
Duration func(childComplexity int) int
Exclusive func(childComplexity int) int
ID func(childComplexity int) int
JobID func(childComplexity int) int
MonitoringStatus func(childComplexity int) int
NumAcc func(childComplexity int) int
NumHWThreads func(childComplexity int) int
NumNodes func(childComplexity int) int
Partition func(childComplexity int) int
Project func(childComplexity int) int
Resources func(childComplexity int) int
2021-12-17 15:49:22 +01:00
SMT func(childComplexity int) int
StartTime func(childComplexity int) int
State func(childComplexity int) int
Tags func(childComplexity int) int
User func(childComplexity int) int
2021-04-07 09:19:21 +02:00
}
JobMetric struct {
2021-12-17 15:49:22 +01:00
Scope func(childComplexity int) int
Series func(childComplexity int) int
StatisticsSeries func(childComplexity int) int
Timestep func(childComplexity int) int
Unit func(childComplexity int) int
2021-04-07 09:19:21 +02:00
}
JobMetricWithName struct {
2021-12-20 10:48:58 +01:00
Metric func(childComplexity int) int
Name func(childComplexity int) int
2021-04-07 09:19:21 +02:00
}
2021-03-31 08:50:53 +02:00
JobResultList struct {
Count func(childComplexity int) int
Items func(childComplexity int) int
Limit func(childComplexity int) int
Offset func(childComplexity int) int
}
JobsStatistics struct {
HistNumNodes func(childComplexity int) int
HistWalltime func(childComplexity int) int
2021-10-26 10:22:02 +02:00
ID func(childComplexity int) int
2021-03-31 08:50:53 +02:00
ShortJobs func(childComplexity int) int
TotalCoreHours func(childComplexity int) int
TotalJobs func(childComplexity int) int
TotalWalltime func(childComplexity int) int
}
2021-04-22 15:00:54 +02:00
MetricConfig struct {
Alert func(childComplexity int) int
Caution func(childComplexity int) int
Name func(childComplexity int) int
Normal func(childComplexity int) int
Peak func(childComplexity int) int
Scope func(childComplexity int) int
Timestep func(childComplexity int) int
Unit func(childComplexity int) int
2021-04-22 15:00:54 +02:00
}
2021-10-26 10:22:02 +02:00
MetricFootprints struct {
Footprints func(childComplexity int) int
Name func(childComplexity int) int
}
2021-12-17 15:49:22 +01:00
MetricStatistics struct {
Avg func(childComplexity int) int
Max func(childComplexity int) int
Min func(childComplexity int) int
}
2021-05-21 09:30:15 +02:00
Mutation struct {
2021-09-23 11:45:20 +02:00
AddTagsToJob func(childComplexity int, job string, tagIds []string) int
CreateTag func(childComplexity int, typeArg string, name string) int
DeleteTag func(childComplexity int, id string) int
RemoveTagsFromJob func(childComplexity int, job string, tagIds []string) int
UpdateConfiguration func(childComplexity int, name string, value string) int
2021-05-21 09:30:15 +02:00
}
2021-12-09 16:25:48 +01:00
NodeMetric struct {
Data func(childComplexity int) int
Name func(childComplexity int) int
}
NodeMetrics struct {
ID func(childComplexity int) int
Metrics func(childComplexity int) int
}
2021-12-17 15:49:22 +01:00
Partition struct {
CoresPerSocket func(childComplexity int) int
FlopRateScalar func(childComplexity int) int
FlopRateSimd func(childComplexity int) int
MemoryBandwidth func(childComplexity int) int
Name func(childComplexity int) int
ProcessorType func(childComplexity int) int
SocketsPerNode func(childComplexity int) int
ThreadsPerCore func(childComplexity int) int
Topology func(childComplexity int) int
}
2021-03-31 08:50:53 +02:00
Query struct {
2021-10-26 10:22:02 +02:00
Clusters func(childComplexity int) int
Job func(childComplexity int, id string) int
2021-12-20 10:48:58 +01:00
JobMetrics func(childComplexity int, id string, metrics []string, scopes []schema.MetricScope) int
2021-10-26 10:22:02 +02:00
Jobs func(childComplexity int, filter []*model.JobFilter, page *model.PageRequest, order *model.OrderByInput) int
JobsFootprints func(childComplexity int, filter []*model.JobFilter, metrics []string) int
JobsStatistics func(childComplexity int, filter []*model.JobFilter, groupBy *model.Aggregate) int
2021-12-09 16:25:48 +01:00
NodeMetrics func(childComplexity int, cluster string, nodes []string, metrics []string, from time.Time, to time.Time) int
2021-10-26 10:22:02 +02:00
RooflineHeatmap func(childComplexity int, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) int
Tags func(childComplexity int) int
}
2022-01-07 09:44:34 +01:00
Resource struct {
Accelerators func(childComplexity int) int
Configuration func(childComplexity int) int
HWThreads func(childComplexity int) int
Hostname func(childComplexity int) int
}
2021-12-17 15:49:22 +01:00
Series struct {
Data func(childComplexity int) int
Hostname func(childComplexity int) int
Id func(childComplexity int) int
Statistics func(childComplexity int) int
}
StatsSeries struct {
Max func(childComplexity int) int
Mean func(childComplexity int) int
Min func(childComplexity int) int
}
Tag struct {
ID func(childComplexity int) int
Name func(childComplexity int) int
Type func(childComplexity int) int
}
TimeRangeOutput struct {
From func(childComplexity int) int
To func(childComplexity int) int
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
Topology struct {
Accelerators func(childComplexity int) int
Core func(childComplexity int) int
Die func(childComplexity int) int
MemoryDomain func(childComplexity int) int
Node func(childComplexity int) int
Socket func(childComplexity int) int
}
}
2021-12-17 15:49:22 +01:00
2021-04-21 10:12:19 +02:00
type JobResolver interface {
2021-12-17 15:49:22 +01:00
Tags(ctx context.Context, obj *schema.Job) ([]*schema.Tag, error)
2021-04-21 10:12:19 +02:00
}
2021-05-21 09:30:15 +02:00
type MutationResolver interface {
2021-12-17 15:49:22 +01:00
CreateTag(ctx context.Context, typeArg string, name string) (*schema.Tag, error)
2021-05-21 09:30:15 +02:00
DeleteTag(ctx context.Context, id string) (string, error)
2021-12-17 15:49:22 +01:00
AddTagsToJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error)
RemoveTagsFromJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error)
2021-09-23 11:45:20 +02:00
UpdateConfiguration(ctx context.Context, name string, value string) (*string, error)
2021-05-21 09:30:15 +02:00
}
2021-03-31 08:50:53 +02:00
type QueryResolver interface {
2021-04-22 15:00:54 +02:00
Clusters(ctx context.Context) ([]*model.Cluster, error)
2021-12-17 15:49:22 +01:00
Tags(ctx context.Context) ([]*schema.Tag, error)
Job(ctx context.Context, id string) (*schema.Job, error)
2021-12-20 10:48:58 +01:00
JobMetrics(ctx context.Context, id string, metrics []string, scopes []schema.MetricScope) ([]*model.JobMetricWithName, error)
2021-10-26 10:22:02 +02:00
JobsFootprints(ctx context.Context, filter []*model.JobFilter, metrics []string) ([]*model.MetricFootprints, error)
Jobs(ctx context.Context, filter []*model.JobFilter, page *model.PageRequest, order *model.OrderByInput) (*model.JobResultList, error)
JobsStatistics(ctx context.Context, filter []*model.JobFilter, groupBy *model.Aggregate) ([]*model.JobsStatistics, error)
RooflineHeatmap(ctx context.Context, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) ([][]float64, error)
2021-12-09 16:25:48 +01:00
NodeMetrics(ctx context.Context, cluster string, nodes []string, metrics []string, from time.Time, to time.Time) ([]*model.NodeMetrics, error)
2021-03-31 08:50:53 +02:00
}
type executableSchema struct {
resolvers ResolverRoot
directives DirectiveRoot
complexity ComplexityRoot
}
func (e *executableSchema) Schema() *ast.Schema {
return parsedSchema
}
func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
ec := executionContext{nil, e}
_ = ec
switch typeName + "." + field {
2021-12-17 15:49:22 +01:00
case "Accelerator.id":
if e.complexity.Accelerator.ID == nil {
break
}
return e.complexity.Accelerator.ID(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Accelerator.model":
if e.complexity.Accelerator.Model == nil {
break
}
return e.complexity.Accelerator.Model(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Accelerator.type":
if e.complexity.Accelerator.Type == nil {
break
}
return e.complexity.Accelerator.Type(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Cluster.filterRanges":
if e.complexity.Cluster.FilterRanges == nil {
break
}
return e.complexity.Cluster.FilterRanges(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Cluster.metricConfig":
2021-04-22 15:00:54 +02:00
if e.complexity.Cluster.MetricConfig == nil {
break
}
return e.complexity.Cluster.MetricConfig(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Cluster.name":
if e.complexity.Cluster.Name == nil {
2021-04-22 15:00:54 +02:00
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.Cluster.Name(childComplexity), true
2021-04-22 15:00:54 +02:00
2021-12-17 15:49:22 +01:00
case "Cluster.partitions":
if e.complexity.Cluster.Partitions == nil {
2021-04-22 15:00:54 +02:00
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.Cluster.Partitions(childComplexity), true
2021-04-22 15:00:54 +02:00
case "FilterRanges.duration":
if e.complexity.FilterRanges.Duration == nil {
break
}
return e.complexity.FilterRanges.Duration(childComplexity), true
case "FilterRanges.numNodes":
if e.complexity.FilterRanges.NumNodes == nil {
break
}
return e.complexity.FilterRanges.NumNodes(childComplexity), true
case "FilterRanges.startTime":
if e.complexity.FilterRanges.StartTime == nil {
break
}
return e.complexity.FilterRanges.StartTime(childComplexity), true
2021-03-31 08:50:53 +02:00
case "HistoPoint.count":
if e.complexity.HistoPoint.Count == nil {
break
}
return e.complexity.HistoPoint.Count(childComplexity), true
case "HistoPoint.value":
if e.complexity.HistoPoint.Value == nil {
break
}
return e.complexity.HistoPoint.Value(childComplexity), true
case "IntRangeOutput.from":
if e.complexity.IntRangeOutput.From == nil {
break
}
return e.complexity.IntRangeOutput.From(childComplexity), true
case "IntRangeOutput.to":
if e.complexity.IntRangeOutput.To == nil {
break
}
return e.complexity.IntRangeOutput.To(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.arrayJobId":
if e.complexity.Job.ArrayJobId == nil {
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.Job.ArrayJobId(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.cluster":
if e.complexity.Job.Cluster == nil {
2021-03-31 08:50:53 +02:00
break
}
return e.complexity.Job.Cluster(childComplexity), true
2021-03-31 08:50:53 +02:00
2021-12-17 15:49:22 +01:00
case "Job.duration":
2021-03-31 08:50:53 +02:00
if e.complexity.Job.Duration == nil {
break
}
return e.complexity.Job.Duration(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.exclusive":
if e.complexity.Job.Exclusive == nil {
break
}
return e.complexity.Job.Exclusive(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.id":
if e.complexity.Job.ID == nil {
break
}
return e.complexity.Job.ID(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.jobId":
2021-03-31 08:50:53 +02:00
if e.complexity.Job.JobID == nil {
break
}
return e.complexity.Job.JobID(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.monitoringStatus":
if e.complexity.Job.MonitoringStatus == nil {
break
}
return e.complexity.Job.MonitoringStatus(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.numAcc":
if e.complexity.Job.NumAcc == nil {
break
}
return e.complexity.Job.NumAcc(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.numHWThreads":
if e.complexity.Job.NumHWThreads == nil {
2021-10-26 10:22:02 +02:00
break
}
return e.complexity.Job.NumHWThreads(childComplexity), true
2021-10-26 10:22:02 +02:00
2021-12-17 15:49:22 +01:00
case "Job.numNodes":
2021-03-31 08:50:53 +02:00
if e.complexity.Job.NumNodes == nil {
break
}
return e.complexity.Job.NumNodes(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.partition":
if e.complexity.Job.Partition == nil {
break
}
return e.complexity.Job.Partition(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.project":
if e.complexity.Job.Project == nil {
break
}
return e.complexity.Job.Project(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.resources":
if e.complexity.Job.Resources == nil {
break
}
return e.complexity.Job.Resources(childComplexity), true
case "Job.SMT":
2021-12-17 15:49:22 +01:00
if e.complexity.Job.SMT == nil {
2021-03-31 08:50:53 +02:00
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.Job.SMT(childComplexity), true
2021-03-31 08:50:53 +02:00
2021-12-17 15:49:22 +01:00
case "Job.startTime":
2021-03-31 08:50:53 +02:00
if e.complexity.Job.StartTime == nil {
break
}
return e.complexity.Job.StartTime(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.state":
2021-10-26 10:22:02 +02:00
if e.complexity.Job.State == nil {
break
}
return e.complexity.Job.State(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.tags":
2021-04-21 10:12:19 +02:00
if e.complexity.Job.Tags == nil {
break
}
return e.complexity.Job.Tags(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Job.user":
if e.complexity.Job.User == nil {
2021-03-31 08:50:53 +02:00
break
}
return e.complexity.Job.User(childComplexity), true
2021-03-31 08:50:53 +02:00
2021-12-17 15:49:22 +01:00
case "JobMetric.scope":
2021-04-07 09:19:21 +02:00
if e.complexity.JobMetric.Scope == nil {
break
}
return e.complexity.JobMetric.Scope(childComplexity), true
2021-12-17 15:49:22 +01:00
case "JobMetric.series":
2021-04-07 09:19:21 +02:00
if e.complexity.JobMetric.Series == nil {
break
}
return e.complexity.JobMetric.Series(childComplexity), true
2021-12-17 15:49:22 +01:00
case "JobMetric.statisticsSeries":
if e.complexity.JobMetric.StatisticsSeries == nil {
2021-04-07 09:19:21 +02:00
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.JobMetric.StatisticsSeries(childComplexity), true
2021-04-07 09:19:21 +02:00
2021-12-17 15:49:22 +01:00
case "JobMetric.timestep":
if e.complexity.JobMetric.Timestep == nil {
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.JobMetric.Timestep(childComplexity), true
2021-12-17 15:49:22 +01:00
case "JobMetric.unit":
if e.complexity.JobMetric.Unit == nil {
2021-04-07 09:19:21 +02:00
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.JobMetric.Unit(childComplexity), true
2021-04-07 09:19:21 +02:00
2021-12-20 10:48:58 +01:00
case "JobMetricWithName.metric":
if e.complexity.JobMetricWithName.Metric == nil {
2021-04-07 09:19:21 +02:00
break
}
2021-12-20 10:48:58 +01:00
return e.complexity.JobMetricWithName.Metric(childComplexity), true
2021-04-07 09:19:21 +02:00
2021-12-17 15:49:22 +01:00
case "JobMetricWithName.name":
if e.complexity.JobMetricWithName.Name == nil {
2021-04-07 09:19:21 +02:00
break
}
2021-12-17 15:49:22 +01:00
return e.complexity.JobMetricWithName.Name(childComplexity), true
2021-04-07 09:19:21 +02:00
2021-03-31 08:50:53 +02:00
case "JobResultList.count":
if e.complexity.JobResultList.Count == nil {
break
}
return e.complexity.JobResultList.Count(childComplexity), true
case "JobResultList.items":
if e.complexity.JobResultList.Items == nil {
break
}
return e.complexity.JobResultList.Items(childComplexity), true
case "JobResultList.limit":
if e.complexity.JobResultList.Limit == nil {
break
}
return e.complexity.JobResultList.Limit(childComplexity), true
case "JobResultList.offset":
if e.complexity.JobResultList.Offset == nil {
break
}
return e.complexity.JobResultList.Offset(childComplexity), true
case "JobsStatistics.histNumNodes":
if e.complexity.JobsStatistics.HistNumNodes == nil {
break
}
return e.complexity.JobsStatistics.HistNumNodes(childComplexity), true
case "JobsStatistics.histWalltime":
if e.complexity.JobsStatistics.HistWalltime == nil {
break
}
return e.complexity.JobsStatistics.HistWalltime(childComplexity), true
2021-10-26 10:22:02 +02:00
case "JobsStatistics.id":
if e.complexity.JobsStatistics.ID == nil {
break
}
return e.complexity.JobsStatistics.ID(childComplexity), true
2021-03-31 08:50:53 +02:00
case "JobsStatistics.shortJobs":
if e.complexity.JobsStatistics.ShortJobs == nil {
break
}
return e.complexity.JobsStatistics.ShortJobs(childComplexity), true
case "JobsStatistics.totalCoreHours":
if e.complexity.JobsStatistics.TotalCoreHours == nil {
break
}
return e.complexity.JobsStatistics.TotalCoreHours(childComplexity), true
case "JobsStatistics.totalJobs":
if e.complexity.JobsStatistics.TotalJobs == nil {
break
}
return e.complexity.JobsStatistics.TotalJobs(childComplexity), true
case "JobsStatistics.totalWalltime":
if e.complexity.JobsStatistics.TotalWalltime == nil {
break
}
return e.complexity.JobsStatistics.TotalWalltime(childComplexity), true
2021-12-20 10:48:58 +01:00
case "MetricConfig.alert":
2021-04-22 15:00:54 +02:00
if e.complexity.MetricConfig.Alert == nil {
break
}
return e.complexity.MetricConfig.Alert(childComplexity), true
2021-12-20 10:48:58 +01:00
case "MetricConfig.caution":
2021-04-22 15:00:54 +02:00
if e.complexity.MetricConfig.Caution == nil {
break
}
return e.complexity.MetricConfig.Caution(childComplexity), true
2021-12-17 15:49:22 +01:00
case "MetricConfig.name":
2021-04-22 15:00:54 +02:00
if e.complexity.MetricConfig.Name == nil {
break
}
return e.complexity.MetricConfig.Name(childComplexity), true
2021-12-20 10:48:58 +01:00
case "MetricConfig.normal":
2021-04-22 15:00:54 +02:00
if e.complexity.MetricConfig.Normal == nil {
break
}
return e.complexity.MetricConfig.Normal(childComplexity), true
2021-12-20 10:48:58 +01:00
case "MetricConfig.peak":
2021-04-22 15:00:54 +02:00
if e.complexity.MetricConfig.Peak == nil {
break
}
return e.complexity.MetricConfig.Peak(childComplexity), true
2021-12-17 15:49:22 +01:00
case "MetricConfig.scope":
if e.complexity.MetricConfig.Scope == nil {
break
}
return e.complexity.MetricConfig.Scope(childComplexity), true
2021-12-17 15:49:22 +01:00
case "MetricConfig.timestep":
if e.complexity.MetricConfig.Timestep == nil {
2021-04-22 15:00:54 +02:00
break
}
return e.complexity.MetricConfig.Timestep(childComplexity), true
2021-04-22 15:00:54 +02:00
2021-12-17 15:49:22 +01:00
case "MetricConfig.unit":
2021-04-22 15:00:54 +02:00
if e.complexity.MetricConfig.Unit == nil {
break
}
return e.complexity.MetricConfig.Unit(childComplexity), true
2021-10-26 10:22:02 +02:00
case "MetricFootprints.footprints":
if e.complexity.MetricFootprints.Footprints == nil {
break
}
return e.complexity.MetricFootprints.Footprints(childComplexity), true
case "MetricFootprints.name":
if e.complexity.MetricFootprints.Name == nil {
break
}
return e.complexity.MetricFootprints.Name(childComplexity), true
2021-12-17 15:49:22 +01:00
case "MetricStatistics.avg":
if e.complexity.MetricStatistics.Avg == nil {
break
}
return e.complexity.MetricStatistics.Avg(childComplexity), true
case "MetricStatistics.max":
if e.complexity.MetricStatistics.Max == nil {
break
}
return e.complexity.MetricStatistics.Max(childComplexity), true
case "MetricStatistics.min":
if e.complexity.MetricStatistics.Min == nil {
break
}
return e.complexity.MetricStatistics.Min(childComplexity), true
2021-05-21 09:30:15 +02:00
case "Mutation.addTagsToJob":
if e.complexity.Mutation.AddTagsToJob == nil {
break
}
args, err := ec.field_Mutation_addTagsToJob_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
return e.complexity.Mutation.AddTagsToJob(childComplexity, args["job"].(string), args["tagIds"].([]string)), true
case "Mutation.createTag":
if e.complexity.Mutation.CreateTag == nil {
break
}
args, err := ec.field_Mutation_createTag_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
return e.complexity.Mutation.CreateTag(childComplexity, args["type"].(string), args["name"].(string)), true
case "Mutation.deleteTag":
if e.complexity.Mutation.DeleteTag == nil {
break
}
args, err := ec.field_Mutation_deleteTag_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
return e.complexity.Mutation.DeleteTag(childComplexity, args["id"].(string)), true
case "Mutation.removeTagsFromJob":
if e.complexity.Mutation.RemoveTagsFromJob == nil {
break
}
args, err := ec.field_Mutation_removeTagsFromJob_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
return e.complexity.Mutation.RemoveTagsFromJob(childComplexity, args["job"].(string), args["tagIds"].([]string)), true
2021-09-23 11:45:20 +02:00
case "Mutation.updateConfiguration":
if e.complexity.Mutation.UpdateConfiguration == nil {
break
}
args, err := ec.field_Mutation_updateConfiguration_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
return e.complexity.Mutation.UpdateConfiguration(childComplexity, args["name"].(string), args["value"].(string)), true
2021-12-09 16:25:48 +01:00
case "NodeMetric.data":
if e.complexity.NodeMetric.Data == nil {
break
}
return e.complexity.NodeMetric.Data(childComplexity), true
case "NodeMetric.name":
if e.complexity.NodeMetric.Name == nil {
break
}
return e.complexity.NodeMetric.Name(childComplexity), true
case "NodeMetrics.id":
if e.complexity.NodeMetrics.ID == nil {
break
}
return e.complexity.NodeMetrics.ID(childComplexity), true
case "NodeMetrics.metrics":
if e.complexity.NodeMetrics.Metrics == nil {
break
}
return e.complexity.NodeMetrics.Metrics(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Partition.coresPerSocket":
if e.complexity.Partition.CoresPerSocket == nil {
break
}
return e.complexity.Partition.CoresPerSocket(childComplexity), true
case "Partition.flopRateScalar":
if e.complexity.Partition.FlopRateScalar == nil {
break
}
return e.complexity.Partition.FlopRateScalar(childComplexity), true
case "Partition.flopRateSimd":
if e.complexity.Partition.FlopRateSimd == nil {
break
}
return e.complexity.Partition.FlopRateSimd(childComplexity), true
case "Partition.memoryBandwidth":
if e.complexity.Partition.MemoryBandwidth == nil {
break
}
return e.complexity.Partition.MemoryBandwidth(childComplexity), true
case "Partition.name":
if e.complexity.Partition.Name == nil {
break
}
return e.complexity.Partition.Name(childComplexity), true
case "Partition.processorType":
if e.complexity.Partition.ProcessorType == nil {
break
}
return e.complexity.Partition.ProcessorType(childComplexity), true
case "Partition.socketsPerNode":
if e.complexity.Partition.SocketsPerNode == nil {
break
}
return e.complexity.Partition.SocketsPerNode(childComplexity), true
case "Partition.threadsPerCore":
if e.complexity.Partition.ThreadsPerCore == nil {
break
}
return e.complexity.Partition.ThreadsPerCore(childComplexity), true
case "Partition.topology":
if e.complexity.Partition.Topology == nil {
break
}
return e.complexity.Partition.Topology(childComplexity), true
2021-04-22 15:00:54 +02:00
case "Query.clusters":
if e.complexity.Query.Clusters == nil {
break
}
return e.complexity.Query.Clusters(childComplexity), true
2021-10-26 10:22:02 +02:00
case "Query.job":
if e.complexity.Query.Job == nil {
2021-03-31 08:50:53 +02:00
break
}
2021-10-26 10:22:02 +02:00
args, err := ec.field_Query_job_args(context.TODO(), rawArgs)
2021-03-31 08:50:53 +02:00
if err != nil {
return 0, false
}
2021-10-26 10:22:02 +02:00
return e.complexity.Query.Job(childComplexity, args["id"].(string)), true
2021-03-31 08:50:53 +02:00
2021-10-26 10:22:02 +02:00
case "Query.jobMetrics":
if e.complexity.Query.JobMetrics == nil {
2021-09-23 11:45:20 +02:00
break
}
2021-10-26 10:22:02 +02:00
args, err := ec.field_Query_jobMetrics_args(context.TODO(), rawArgs)
2021-09-23 11:45:20 +02:00
if err != nil {
return 0, false
}
2021-12-20 10:48:58 +01:00
return e.complexity.Query.JobMetrics(childComplexity, args["id"].(string), args["metrics"].([]string), args["scopes"].([]schema.MetricScope)), true
2021-09-23 11:45:20 +02:00
2021-10-26 10:22:02 +02:00
case "Query.jobs":
if e.complexity.Query.Jobs == nil {
2021-04-07 09:19:21 +02:00
break
}
2021-10-26 10:22:02 +02:00
args, err := ec.field_Query_jobs_args(context.TODO(), rawArgs)
2021-04-07 09:19:21 +02:00
if err != nil {
return 0, false
}
2021-10-26 10:22:02 +02:00
return e.complexity.Query.Jobs(childComplexity, args["filter"].([]*model.JobFilter), args["page"].(*model.PageRequest), args["order"].(*model.OrderByInput)), true
2021-04-07 09:19:21 +02:00
2021-10-26 10:22:02 +02:00
case "Query.jobsFootprints":
if e.complexity.Query.JobsFootprints == nil {
2021-03-31 08:50:53 +02:00
break
}
2021-10-26 10:22:02 +02:00
args, err := ec.field_Query_jobsFootprints_args(context.TODO(), rawArgs)
2021-03-31 08:50:53 +02:00
if err != nil {
return 0, false
}
2021-10-26 10:22:02 +02:00
return e.complexity.Query.JobsFootprints(childComplexity, args["filter"].([]*model.JobFilter), args["metrics"].([]string)), true
2021-03-31 08:50:53 +02:00
2021-04-21 10:12:19 +02:00
case "Query.jobsStatistics":
if e.complexity.Query.JobsStatistics == nil {
2021-04-14 18:53:18 +02:00
break
}
2021-04-21 10:12:19 +02:00
args, err := ec.field_Query_jobsStatistics_args(context.TODO(), rawArgs)
2021-04-14 18:53:18 +02:00
if err != nil {
return 0, false
}
2021-10-26 10:22:02 +02:00
return e.complexity.Query.JobsStatistics(childComplexity, args["filter"].([]*model.JobFilter), args["groupBy"].(*model.Aggregate)), true
2021-04-14 18:53:18 +02:00
2021-12-09 16:25:48 +01:00
case "Query.nodeMetrics":
if e.complexity.Query.NodeMetrics == nil {
break
}
args, err := ec.field_Query_nodeMetrics_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
return e.complexity.Query.NodeMetrics(childComplexity, args["cluster"].(string), args["nodes"].([]string), args["metrics"].([]string), args["from"].(time.Time), args["to"].(time.Time)), true
2021-09-23 11:45:20 +02:00
case "Query.rooflineHeatmap":
if e.complexity.Query.RooflineHeatmap == nil {
break
}
args, err := ec.field_Query_rooflineHeatmap_args(context.TODO(), rawArgs)
if err != nil {
return 0, false
}
2021-10-26 10:22:02 +02:00
return e.complexity.Query.RooflineHeatmap(childComplexity, args["filter"].([]*model.JobFilter), args["rows"].(int), args["cols"].(int), args["minX"].(float64), args["minY"].(float64), args["maxX"].(float64), args["maxY"].(float64)), true
2021-09-23 11:45:20 +02:00
2021-04-21 10:12:19 +02:00
case "Query.tags":
if e.complexity.Query.Tags == nil {
2021-03-31 08:50:53 +02:00
break
}
return e.complexity.Query.Tags(childComplexity), true
2022-01-07 09:44:34 +01:00
case "Resource.accelerators":
if e.complexity.Resource.Accelerators == nil {
break
}
return e.complexity.Resource.Accelerators(childComplexity), true
case "Resource.configuration":
if e.complexity.Resource.Configuration == nil {
break
}
return e.complexity.Resource.Configuration(childComplexity), true
case "Resource.hwthreads":
if e.complexity.Resource.HWThreads == nil {
break
}
return e.complexity.Resource.HWThreads(childComplexity), true
case "Resource.hostname":
if e.complexity.Resource.Hostname == nil {
break
}
return e.complexity.Resource.Hostname(childComplexity), true
2021-12-17 15:49:22 +01:00
case "Series.data":
if e.complexity.Series.Data == nil {
break
}
return e.complexity.Series.Data(childComplexity), true
case "Series.hostname":
if e.complexity.Series.Hostname == nil {
break
}
return e.complexity.Series.Hostname(childComplexity), true
case "Series.id":
if e.complexity.Series.Id == nil {
break
}
return e.complexity.Series.Id(childComplexity), true
case "Series.statistics":
if e.complexity.Series.Statistics == nil {
break
}
return e.complexity.Series.Statistics(childComplexity), true
case "StatsSeries.max":
if e.complexity.StatsSeries.Max == nil {
break
}
return e.complexity.StatsSeries.Max(childComplexity), true
case "StatsSeries.mean":
if e.complexity.StatsSeries.Mean == nil {
break
}
return e.complexity.StatsSeries.Mean(childComplexity), true
case "StatsSeries.min":
if e.complexity.StatsSeries.Min == nil {
break
}
return e.complexity.StatsSeries.Min(childComplexity), true
case "Tag.id":
if e.complexity.Tag.ID == nil {
break
}
return e.complexity.Tag.ID(childComplexity), true
case "Tag.name":
if e.complexity.Tag.Name == nil {
break
}
return e.complexity.Tag.Name(childComplexity), true
case "Tag.type":
if e.complexity.Tag.Type == nil {
break
}
return e.complexity.Tag.Type(childComplexity), true
case "TimeRangeOutput.from":
if e.complexity.TimeRangeOutput.From == nil {
break
}
return e.complexity.TimeRangeOutput.From(childComplexity), true
case "TimeRangeOutput.to":
if e.complexity.TimeRangeOutput.To == nil {
break
2021-03-31 08:50:53 +02:00
}
return e.complexity.TimeRangeOutput.To(childComplexity), true
2021-03-31 08:50:53 +02:00
2021-12-17 15:49:22 +01:00
case "Topology.accelerators":
if e.complexity.Topology.Accelerators == nil {
break
}
return e.complexity.Topology.Accelerators(childComplexity), true
case "Topology.core":
if e.complexity.Topology.Core == nil {
break
}
return e.complexity.Topology.Core(childComplexity), true
case "Topology.die":
if e.complexity.Topology.Die == nil {
break
}
return e.complexity.Topology.Die(childComplexity), true
case "Topology.memoryDomain":
if e.complexity.Topology.MemoryDomain == nil {
break
}
return e.complexity.Topology.MemoryDomain(childComplexity), true
case "Topology.node":
if e.complexity.Topology.Node == nil {
break
}
return e.complexity.Topology.Node(childComplexity), true
case "Topology.socket":
if e.complexity.Topology.Socket == nil {
break
}
return e.complexity.Topology.Socket(childComplexity), true
2021-03-31 08:50:53 +02:00
}
return 0, false
}
func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
rc := graphql.GetOperationContext(ctx)
ec := executionContext{rc, e}
first := true
switch rc.Operation.Operation {
case ast.Query:
return func(ctx context.Context) *graphql.Response {
if !first {
return nil
}
first = false
data := ec._Query(ctx, rc.Operation.SelectionSet)
var buf bytes.Buffer
data.MarshalGQL(&buf)
2021-05-21 09:30:15 +02:00
return &graphql.Response{
Data: buf.Bytes(),
}
}
case ast.Mutation:
return func(ctx context.Context) *graphql.Response {
if !first {
return nil
}
first = false
data := ec._Mutation(ctx, rc.Operation.SelectionSet)
var buf bytes.Buffer
data.MarshalGQL(&buf)
2021-03-31 08:50:53 +02:00
return &graphql.Response{
Data: buf.Bytes(),
}
}
default:
return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
}
}
type executionContext struct {
*graphql.OperationContext
*executableSchema
}
func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
if ec.DisableIntrospection {
return nil, errors.New("introspection disabled")
}
return introspection.WrapSchema(parsedSchema), nil
}
func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
if ec.DisableIntrospection {
return nil, errors.New("introspection disabled")
}
return introspection.WrapTypeFromDef(parsedSchema, parsedSchema.Types[name]), nil
}
var sources = []*ast.Source{
2021-12-17 15:49:22 +01:00
{Name: "graph/schema.graphqls", Input: `scalar Time
scalar NullableFloat
scalar MetricScope
scalar JobState
type Job {
id: ID!
jobId: Int!
user: String!
project: String!
cluster: String!
startTime: Time!
duration: Int!
numNodes: Int!
numHWThreads: Int!
numAcc: Int!
SMT: Int!
2021-12-17 15:49:22 +01:00
exclusive: Int!
partition: String!
arrayJobId: Int!
monitoringStatus: Int!
state: JobState!
tags: [Tag!]!
2022-01-07 09:44:34 +01:00
resources: [Resource!]!
}
2021-12-17 15:49:22 +01:00
type Cluster {
name: String!
metricConfig: [MetricConfig!]!
filterRanges: FilterRanges!
partitions: [Partition!]!
}
2021-12-17 15:49:22 +01:00
type Partition {
name: String!
processorType: String!
socketsPerNode: Int!
coresPerSocket: Int!
threadsPerCore: Int!
flopRateScalar: Int!
flopRateSimd: Int!
memoryBandwidth: Int!
topology: Topology!
2021-10-26 10:22:02 +02:00
}
2021-12-17 15:49:22 +01:00
type Topology {
node: [Int!]
socket: [[Int!]!]
memoryDomain: [[Int!]!]
die: [[Int!]!]
core: [[Int!]!]
accelerators: [Accelerator!]
2021-09-23 11:45:20 +02:00
}
2021-04-21 10:12:19 +02:00
2021-12-17 15:49:22 +01:00
type Accelerator {
id: String!
type: String!
model: String!
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
type MetricConfig {
name: String!
unit: String!
2022-01-07 09:44:34 +01:00
scope: MetricScope!
2021-12-17 15:49:22 +01:00
timestep: Int!
2021-12-20 10:48:58 +01:00
peak: Float!
normal: Float!
caution: Float!
alert: Float!
2021-12-17 15:49:22 +01:00
}
type Tag {
id: ID!
type: String!
name: String!
2021-04-22 15:00:54 +02:00
}
2022-01-07 09:44:34 +01:00
type Resource {
2021-12-17 15:49:22 +01:00
hostname: String!
hwthreads: [Int!]
accelerators: [Int!]
configuration: String
}
type JobMetricWithName {
2021-12-20 10:48:58 +01:00
name: String!
metric: JobMetric!
2021-04-22 15:00:54 +02:00
}
2021-04-07 09:19:21 +02:00
type JobMetric {
2021-12-17 15:49:22 +01:00
unit: String!
scope: MetricScope!
timestep: Int!
2022-01-07 09:44:34 +01:00
series: [Series!]
statisticsSeries: StatsSeries
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
type Series {
hostname: String!
id: Int
statistics: MetricStatistics
data: [NullableFloat!]!
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
type MetricStatistics {
avg: Float!
min: Float!
max: Float!
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
type StatsSeries {
2022-01-07 09:44:34 +01:00
mean: [NullableFloat!]!
min: [NullableFloat!]!
max: [NullableFloat!]!
2021-04-14 18:53:18 +02:00
}
2021-10-26 10:22:02 +02:00
type MetricFootprints {
name: String!
footprints: [NullableFloat!]!
}
enum Aggregate { USER, PROJECT, CLUSTER }
2021-12-09 16:25:48 +01:00
type NodeMetric {
name: String!
data: [NullableFloat!]!
}
type NodeMetrics {
id: String!
metrics: [NodeMetric!]!
}
2021-03-31 08:50:53 +02:00
type Query {
2021-10-26 10:22:02 +02:00
clusters: [Cluster!]! # List of all clusters
2021-12-17 15:49:22 +01:00
tags: [Tag!]! # List of all tags
2021-10-26 10:22:02 +02:00
job(id: ID!): Job
2021-12-20 10:48:58 +01:00
jobMetrics(id: ID!, metrics: [String!], scopes: [MetricScope!]): [JobMetricWithName!]!
2021-10-26 10:22:02 +02:00
jobsFootprints(filter: [JobFilter!], metrics: [String!]!): [MetricFootprints]!
jobs(filter: [JobFilter!], page: PageRequest, order: OrderByInput): JobResultList!
jobsStatistics(filter: [JobFilter!], groupBy: Aggregate): [JobsStatistics!]!
rooflineHeatmap(filter: [JobFilter!]!, rows: Int!, cols: Int!, minX: Float!, minY: Float!, maxX: Float!, maxY: Float!): [[Float!]!]!
2021-12-09 16:25:48 +01:00
nodeMetrics(cluster: ID!, nodes: [String!], metrics: [String!], from: Time!, to: Time!): [NodeMetrics!]!
2021-03-31 08:50:53 +02:00
}
2021-05-21 09:30:15 +02:00
type Mutation {
2021-12-17 15:49:22 +01:00
createTag(type: String!, name: String!): Tag!
2021-05-21 09:30:15 +02:00
deleteTag(id: ID!): ID!
2021-12-17 15:49:22 +01:00
addTagsToJob(job: ID!, tagIds: [ID!]!): [Tag!]!
removeTagsFromJob(job: ID!, tagIds: [ID!]!): [Tag!]!
2021-09-23 11:45:20 +02:00
updateConfiguration(name: String!, value: String!): String
}
2021-12-17 15:49:22 +01:00
type IntRangeOutput { from: Int!, to: Int! }
type TimeRangeOutput { from: Time!, to: Time! }
2021-05-21 09:30:15 +02:00
2021-09-23 11:45:20 +02:00
type FilterRanges {
2021-10-26 10:22:02 +02:00
duration: IntRangeOutput!
numNodes: IntRangeOutput!
2021-09-23 11:45:20 +02:00
startTime: TimeRangeOutput!
}
2021-05-21 09:30:15 +02:00
2021-03-31 08:50:53 +02:00
input JobFilter {
2021-10-26 10:22:02 +02:00
tags: [ID!]
jobId: StringInput
user: StringInput
project: StringInput
cluster: StringInput
2021-10-26 10:22:02 +02:00
duration: IntRange
numNodes: IntRange
startTime: TimeRange
2021-12-17 15:49:22 +01:00
state: [JobState!]
flopsAnyAvg: FloatRange
2021-10-26 10:22:02 +02:00
memBwAvg: FloatRange
loadAvg: FloatRange
memUsedMax: FloatRange
2021-03-31 08:50:53 +02:00
}
input OrderByInput {
field: String!
2021-10-26 10:22:02 +02:00
order: SortDirectionEnum! = ASC
2021-03-31 08:50:53 +02:00
}
enum SortDirectionEnum {
DESC
ASC
}
input StringInput {
2021-10-26 10:22:02 +02:00
eq: String
contains: String
2021-03-31 08:50:53 +02:00
startsWith: String
2021-10-26 10:22:02 +02:00
endsWith: String
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
input IntRange { from: Int!, to: Int! }
input FloatRange { from: Float!, to: Float! }
input TimeRange { from: Time, to: Time }
2021-03-31 08:50:53 +02:00
type JobResultList {
2021-10-26 10:22:02 +02:00
items: [Job!]!
2021-03-31 08:50:53 +02:00
offset: Int
2021-10-26 10:22:02 +02:00
limit: Int
count: Int
2021-03-31 08:50:53 +02:00
}
type HistoPoint {
count: Int!
value: Int!
}
type JobsStatistics {
2021-10-26 10:22:02 +02:00
id: ID! # If ` + "`" + `groupBy` + "`" + ` was used, ID of the user/project/cluster
totalJobs: Int! # Number of jobs that matched
shortJobs: Int! # Number of jobs with a duration of less than 2 minutes
totalWalltime: Int! # Sum of the duration of all matched jobs in hours
totalCoreHours: Int! # Sum of the core hours of all matched jobs
histWalltime: [HistoPoint!]! # value: hour, count: number of jobs with a rounded duration of value
histNumNodes: [HistoPoint!]! # value: number of nodes, count: number of jobs with that number of nodes
2021-09-23 11:45:20 +02:00
}
2021-03-31 08:50:53 +02:00
input PageRequest {
2021-09-23 11:45:20 +02:00
itemsPerPage: Int!
2021-10-26 10:22:02 +02:00
page: Int!
2021-03-31 08:50:53 +02:00
}
`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)
// endregion ************************** generated!.gotpl **************************
// region ***************************** args.gotpl *****************************
2021-05-21 09:30:15 +02:00
func (ec *executionContext) field_Mutation_addTagsToJob_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["job"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("job"))
arg0, err = ec.unmarshalNID2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["job"] = arg0
var arg1 []string
if tmp, ok := rawArgs["tagIds"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tagIds"))
arg1, err = ec.unmarshalNID2ᚕstringᚄ(ctx, tmp)
if err != nil {
return nil, err
}
}
args["tagIds"] = arg1
return args, nil
}
func (ec *executionContext) field_Mutation_createTag_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["type"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("type"))
arg0, err = ec.unmarshalNString2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["type"] = arg0
var arg1 string
if tmp, ok := rawArgs["name"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
arg1, err = ec.unmarshalNString2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["name"] = arg1
return args, nil
}
func (ec *executionContext) field_Mutation_deleteTag_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["id"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
arg0, err = ec.unmarshalNID2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["id"] = arg0
return args, nil
}
func (ec *executionContext) field_Mutation_removeTagsFromJob_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["job"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("job"))
arg0, err = ec.unmarshalNID2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["job"] = arg0
var arg1 []string
if tmp, ok := rawArgs["tagIds"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tagIds"))
arg1, err = ec.unmarshalNID2ᚕstringᚄ(ctx, tmp)
if err != nil {
return nil, err
}
}
args["tagIds"] = arg1
return args, nil
}
2021-09-23 11:45:20 +02:00
func (ec *executionContext) field_Mutation_updateConfiguration_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["name"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
arg0, err = ec.unmarshalNString2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["name"] = arg0
var arg1 string
if tmp, ok := rawArgs["value"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("value"))
arg1, err = ec.unmarshalNString2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["value"] = arg1
return args, nil
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) field_Query___type_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["name"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("name"))
arg0, err = ec.unmarshalNString2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["name"] = arg0
return args, nil
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) field_Query_jobMetrics_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2021-04-07 09:19:21 +02:00
var err error
args := map[string]interface{}{}
var arg0 string
2021-05-21 09:30:15 +02:00
if tmp, ok := rawArgs["id"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
arg0, err = ec.unmarshalNID2string(ctx, tmp)
2021-04-07 09:19:21 +02:00
if err != nil {
return nil, err
}
}
2021-05-21 09:30:15 +02:00
args["id"] = arg0
2021-10-26 10:22:02 +02:00
var arg1 []string
2021-09-23 11:45:20 +02:00
if tmp, ok := rawArgs["metrics"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metrics"))
2021-10-26 10:22:02 +02:00
arg1, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
2021-09-23 11:45:20 +02:00
if err != nil {
return nil, err
}
}
args["metrics"] = arg1
2021-12-20 10:48:58 +01:00
var arg2 []schema.MetricScope
if tmp, ok := rawArgs["scopes"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("scopes"))
arg2, err = ec.unmarshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScopeᚄ(ctx, tmp)
if err != nil {
return nil, err
}
}
args["scopes"] = arg2
2021-09-23 11:45:20 +02:00
return args, nil
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) field_Query_job_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
2021-03-31 08:50:53 +02:00
var err error
args := map[string]interface{}{}
var arg0 string
2021-10-26 10:22:02 +02:00
if tmp, ok := rawArgs["id"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("id"))
arg0, err = ec.unmarshalNID2string(ctx, tmp)
2021-03-31 08:50:53 +02:00
if err != nil {
return nil, err
}
}
2021-10-26 10:22:02 +02:00
args["id"] = arg0
return args, nil
}
func (ec *executionContext) field_Query_jobsFootprints_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 []*model.JobFilter
if tmp, ok := rawArgs["filter"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
arg0, err = ec.unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilterᚄ(ctx, tmp)
if err != nil {
return nil, err
}
}
2021-10-26 10:22:02 +02:00
args["filter"] = arg0
var arg1 []string
if tmp, ok := rawArgs["metrics"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metrics"))
2021-10-26 10:22:02 +02:00
arg1, err = ec.unmarshalNString2ᚕstringᚄ(ctx, tmp)
2021-04-07 09:19:21 +02:00
if err != nil {
return nil, err
}
}
2021-10-26 10:22:02 +02:00
args["metrics"] = arg1
2021-04-07 09:19:21 +02:00
return args, nil
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) field_Query_jobsStatistics_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
2021-10-26 10:22:02 +02:00
var arg0 []*model.JobFilter
2021-03-31 08:50:53 +02:00
if tmp, ok := rawArgs["filter"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
2021-10-26 10:22:02 +02:00
arg0, err = ec.unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilterᚄ(ctx, tmp)
2021-03-31 08:50:53 +02:00
if err != nil {
return nil, err
}
}
args["filter"] = arg0
2021-10-26 10:22:02 +02:00
var arg1 *model.Aggregate
if tmp, ok := rawArgs["groupBy"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("groupBy"))
arg1, err = ec.unmarshalOAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐAggregate(ctx, tmp)
if err != nil {
return nil, err
}
}
args["groupBy"] = arg1
2021-03-31 08:50:53 +02:00
return args, nil
}
func (ec *executionContext) field_Query_jobs_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
2021-10-26 10:22:02 +02:00
var arg0 []*model.JobFilter
2021-03-31 08:50:53 +02:00
if tmp, ok := rawArgs["filter"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
2021-10-26 10:22:02 +02:00
arg0, err = ec.unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilterᚄ(ctx, tmp)
2021-03-31 08:50:53 +02:00
if err != nil {
return nil, err
}
2021-03-31 08:50:53 +02:00
}
args["filter"] = arg0
var arg1 *model.PageRequest
if tmp, ok := rawArgs["page"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("page"))
arg1, err = ec.unmarshalOPageRequest2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐPageRequest(ctx, tmp)
if err != nil {
return nil, err
}
2021-03-31 08:50:53 +02:00
}
args["page"] = arg1
var arg2 *model.OrderByInput
if tmp, ok := rawArgs["order"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("order"))
arg2, err = ec.unmarshalOOrderByInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐOrderByInput(ctx, tmp)
if err != nil {
return nil, err
}
}
args["order"] = arg2
return args, nil
2021-03-31 08:50:53 +02:00
}
2021-12-09 16:25:48 +01:00
func (ec *executionContext) field_Query_nodeMetrics_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 string
if tmp, ok := rawArgs["cluster"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cluster"))
arg0, err = ec.unmarshalNID2string(ctx, tmp)
if err != nil {
return nil, err
}
}
args["cluster"] = arg0
var arg1 []string
if tmp, ok := rawArgs["nodes"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("nodes"))
arg1, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
if err != nil {
return nil, err
}
}
args["nodes"] = arg1
var arg2 []string
if tmp, ok := rawArgs["metrics"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("metrics"))
arg2, err = ec.unmarshalOString2ᚕstringᚄ(ctx, tmp)
if err != nil {
return nil, err
}
}
args["metrics"] = arg2
var arg3 time.Time
if tmp, ok := rawArgs["from"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("from"))
arg3, err = ec.unmarshalNTime2timeᚐTime(ctx, tmp)
if err != nil {
return nil, err
}
}
args["from"] = arg3
var arg4 time.Time
if tmp, ok := rawArgs["to"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("to"))
arg4, err = ec.unmarshalNTime2timeᚐTime(ctx, tmp)
if err != nil {
return nil, err
}
}
args["to"] = arg4
return args, nil
}
2021-09-23 11:45:20 +02:00
func (ec *executionContext) field_Query_rooflineHeatmap_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
2021-10-26 10:22:02 +02:00
var arg0 []*model.JobFilter
2021-09-23 11:45:20 +02:00
if tmp, ok := rawArgs["filter"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("filter"))
2021-10-26 10:22:02 +02:00
arg0, err = ec.unmarshalNJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilterᚄ(ctx, tmp)
2021-09-23 11:45:20 +02:00
if err != nil {
return nil, err
}
}
args["filter"] = arg0
var arg1 int
if tmp, ok := rawArgs["rows"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("rows"))
arg1, err = ec.unmarshalNInt2int(ctx, tmp)
if err != nil {
return nil, err
}
}
args["rows"] = arg1
var arg2 int
if tmp, ok := rawArgs["cols"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cols"))
arg2, err = ec.unmarshalNInt2int(ctx, tmp)
if err != nil {
return nil, err
}
}
args["cols"] = arg2
var arg3 float64
if tmp, ok := rawArgs["minX"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("minX"))
arg3, err = ec.unmarshalNFloat2float64(ctx, tmp)
if err != nil {
return nil, err
}
}
args["minX"] = arg3
var arg4 float64
if tmp, ok := rawArgs["minY"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("minY"))
arg4, err = ec.unmarshalNFloat2float64(ctx, tmp)
if err != nil {
return nil, err
}
}
args["minY"] = arg4
var arg5 float64
if tmp, ok := rawArgs["maxX"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("maxX"))
arg5, err = ec.unmarshalNFloat2float64(ctx, tmp)
if err != nil {
return nil, err
}
}
args["maxX"] = arg5
var arg6 float64
if tmp, ok := rawArgs["maxY"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("maxY"))
arg6, err = ec.unmarshalNFloat2float64(ctx, tmp)
if err != nil {
return nil, err
}
}
args["maxY"] = arg6
return args, nil
}
func (ec *executionContext) field___Type_enumValues_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 bool
if tmp, ok := rawArgs["includeDeprecated"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
if err != nil {
return nil, err
2021-03-31 08:50:53 +02:00
}
}
args["includeDeprecated"] = arg0
return args, nil
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {
var err error
args := map[string]interface{}{}
var arg0 bool
if tmp, ok := rawArgs["includeDeprecated"]; ok {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("includeDeprecated"))
arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)
if err != nil {
return nil, err
}
2021-03-31 08:50:53 +02:00
}
args["includeDeprecated"] = arg0
return args, nil
2021-03-31 08:50:53 +02:00
}
// endregion ***************************** args.gotpl *****************************
// region ************************** directives.gotpl **************************
// endregion ************************** directives.gotpl **************************
// region **************************** field.gotpl *****************************
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Accelerator_id(ctx context.Context, field graphql.CollectedField, obj *model.Accelerator) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Accelerator",
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.ID, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Accelerator_type(ctx context.Context, field graphql.CollectedField, obj *model.Accelerator) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Accelerator",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Type, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Accelerator_model(ctx context.Context, field graphql.CollectedField, obj *model.Accelerator) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Accelerator",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Model, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Cluster_name(ctx context.Context, field graphql.CollectedField, obj *model.Cluster) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-04-22 15:00:54 +02:00
Object: "Cluster",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Name, nil
2021-03-31 08:50:53 +02:00
})
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")
}
2021-03-31 08:50:53 +02:00
return graphql.Null
}
2021-04-22 15:00:54 +02:00
res := resTmp.(string)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-04-22 15:00:54 +02:00
return ec.marshalNString2string(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Cluster_metricConfig(ctx context.Context, field graphql.CollectedField, obj *model.Cluster) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-04-22 15:00:54 +02:00
Object: "Cluster",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.MetricConfig, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.MetricConfig)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNMetricConfig2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricConfigᚄ(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Cluster_filterRanges(ctx context.Context, field graphql.CollectedField, obj *model.Cluster) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-04-22 15:00:54 +02:00
Object: "Cluster",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.FilterRanges, 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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*model.FilterRanges)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFilterRanges2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐFilterRanges(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Cluster_partitions(ctx context.Context, field graphql.CollectedField, obj *model.Cluster) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-04-22 15:00:54 +02:00
Object: "Cluster",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Partitions, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.Partition)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNPartition2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐPartitionᚄ(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _FilterRanges_duration(ctx context.Context, field graphql.CollectedField, obj *model.FilterRanges) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "FilterRanges",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Duration, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*model.IntRangeOutput)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNIntRangeOutput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐIntRangeOutput(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _FilterRanges_numNodes(ctx context.Context, field graphql.CollectedField, obj *model.FilterRanges) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "FilterRanges",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.NumNodes, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*model.IntRangeOutput)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNIntRangeOutput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐIntRangeOutput(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _FilterRanges_startTime(ctx context.Context, field graphql.CollectedField, obj *model.FilterRanges) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "FilterRanges",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.StartTime, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*model.TimeRangeOutput)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNTimeRangeOutput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐTimeRangeOutput(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _HistoPoint_count(ctx context.Context, field graphql.CollectedField, obj *model.HistoPoint) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "HistoPoint",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Count, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-04-22 15:00:54 +02:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-04-22 15:00:54 +02:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _HistoPoint_value(ctx context.Context, field graphql.CollectedField, obj *model.HistoPoint) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "HistoPoint",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Value, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _IntRangeOutput_from(ctx context.Context, field graphql.CollectedField, obj *model.IntRangeOutput) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "IntRangeOutput",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
2021-10-26 10:22:02 +02:00
IsMethod: false,
IsResolver: false,
2021-04-07 09:19:21 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.From, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _IntRangeOutput_to(ctx context.Context, field graphql.CollectedField, obj *model.IntRangeOutput) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "IntRangeOutput",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.To, nil
2021-04-07 09:19:21 +02:00
})
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")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_id(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.ID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int64)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNID2int64(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_jobId(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.JobID, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int64)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int64(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_user(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.User, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_project(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Project, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_cluster(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Cluster, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_startTime(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-21 10:12:19 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Job",
2021-04-21 10:12:19 +02:00
Field: field,
Args: nil,
2021-04-22 15:00:54 +02:00
IsMethod: false,
IsResolver: false,
2021-04-21 10:12:19 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.StartTime, nil
2021-04-21 10:12:19 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-21 10:12:19 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(time.Time)
2021-04-21 10:12:19 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
2021-04-21 10:12:19 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_duration(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-04-22 15:00:54 +02:00
Object: "Job",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Duration, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_numNodes(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-04-22 15:00:54 +02:00
Object: "Job",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.NumNodes, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_numHWThreads(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-04-22 15:00:54 +02:00
Object: "Job",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.NumHWThreads, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_numAcc(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.NumAcc, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_SMT(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.SMT, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_exclusive(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Exclusive, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_partition(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Partition, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_arrayJobId(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.ArrayJobId, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_monitoringStatus(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-10-26 10:22:02 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.MonitoringStatus, nil
2021-10-26 10:22:02 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int32)
2021-10-26 10:22:02 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int32(ctx, field.Selections, res)
2021-10-26 10:22:02 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_state(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
2021-04-22 15:00:54 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.State, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(schema.JobState)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobState(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_tags(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
2021-10-26 10:22:02 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
2021-10-26 10:22:02 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Job().Tags(rctx, obj)
2021-10-26 10:22:02 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*schema.Tag)
2021-10-26 10:22:02 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTagᚄ(ctx, field.Selections, res)
2021-10-26 10:22:02 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job_resources(ctx context.Context, field graphql.CollectedField, obj *schema.Job) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Job",
Field: field,
Args: nil,
2022-01-07 09:44:34 +01:00
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Resources, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-09-23 11:45:20 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.([]*schema.Resource)
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalNResource2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐResourceᚄ(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobMetric_unit(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobMetric",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Unit, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
res := resTmp.(string)
2021-04-22 15:00:54 +02:00
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobMetric_scope(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobMetric",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Scope, nil
2021-04-22 15:00:54 +02:00
})
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")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(schema.MetricScope)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScope(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobMetric_timestep(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobMetric",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Timestep, 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.(int)
fc.Result = res
return ec.marshalNInt2int(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobMetric_series(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobMetric",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Series, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]schema.Series)
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalOSeries2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐSeriesᚄ(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobMetric_statisticsSeries(ctx context.Context, field graphql.CollectedField, obj *schema.JobMetric) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobMetric",
Field: field,
Args: nil,
2022-01-07 09:44:34 +01:00
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.StatisticsSeries, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.(*schema.StatsSeries)
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalOStatsSeries2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐStatsSeries(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobMetricWithName_name(ctx context.Context, field graphql.CollectedField, obj *model.JobMetricWithName) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobMetricWithName",
Field: field,
Args: nil,
2021-09-23 11:45:20 +02:00
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Name, 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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-20 10:48:58 +01:00
func (ec *executionContext) _JobMetricWithName_metric(ctx context.Context, field graphql.CollectedField, obj *model.JobMetricWithName) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobMetricWithName",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-20 10:48:58 +01:00
return obj.Metric, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-20 10:48:58 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*schema.JobMetric)
fc.Result = res
2021-12-20 10:48:58 +01:00
return ec.marshalNJobMetric2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobMetric(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobResultList_items(ctx context.Context, field graphql.CollectedField, obj *model.JobResultList) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobResultList",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Items, nil
2021-04-22 15:00:54 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*schema.Job)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNJob2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobᚄ(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobResultList_offset(ctx context.Context, field graphql.CollectedField, obj *model.JobResultList) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobResultList",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Offset, nil
2021-04-22 15:00:54 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*int)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobResultList_limit(ctx context.Context, field graphql.CollectedField, obj *model.JobResultList) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobResultList",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Limit, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*int)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobResultList_count(ctx context.Context, field graphql.CollectedField, obj *model.JobResultList) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobResultList",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Count, nil
2021-04-22 15:00:54 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*int)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobsStatistics_id(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobsStatistics",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.ID, nil
2021-04-22 15:00:54 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNID2string(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobsStatistics_totalJobs(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobsStatistics",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.TotalJobs, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobsStatistics_shortJobs(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobsStatistics",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.ShortJobs, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobsStatistics_totalWalltime(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobsStatistics",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.TotalWalltime, nil
2021-04-07 09:19:21 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobsStatistics_totalCoreHours(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobsStatistics",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.TotalCoreHours, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobsStatistics_histWalltime(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobsStatistics",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.HistWalltime, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.HistoPoint)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐHistoPointᚄ(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _JobsStatistics_histNumNodes(ctx context.Context, field graphql.CollectedField, obj *model.JobsStatistics) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "JobsStatistics",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.HistNumNodes, 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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.HistoPoint)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐHistoPointᚄ(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricConfig_name(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Name, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-17 15:49:22 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricConfig_unit(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Unit, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-17 15:49:22 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricConfig_scope(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Scope, nil
2021-04-07 09:19:21 +02:00
})
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
}
2022-01-07 09:44:34 +01:00
res := resTmp.(schema.MetricScope)
2021-04-07 09:19:21 +02:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScope(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricConfig_timestep(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Timestep, nil
2021-04-22 15:00:54 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-17 15:49:22 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-20 10:48:58 +01:00
func (ec *executionContext) _MetricConfig_peak(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Peak, nil
2021-04-22 15:00:54 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-17 15:49:22 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(float64)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2float64(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-20 10:48:58 +01:00
func (ec *executionContext) _MetricConfig_normal(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Normal, nil
2021-04-22 15:00:54 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-17 15:49:22 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-22 15:00:54 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(float64)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2float64(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-20 10:48:58 +01:00
func (ec *executionContext) _MetricConfig_caution(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Caution, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(float64)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2float64(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-20 10:48:58 +01:00
func (ec *executionContext) _MetricConfig_alert(ctx context.Context, field graphql.CollectedField, obj *model.MetricConfig) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricConfig",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Alert, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(float64)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2float64(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricFootprints_name(ctx context.Context, field graphql.CollectedField, obj *model.MetricFootprints) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricFootprints",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Name, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-04-22 15:00:54 +02:00
res := resTmp.(string)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-04-22 15:00:54 +02:00
return ec.marshalNString2string(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricFootprints_footprints(ctx context.Context, field graphql.CollectedField, obj *model.MetricFootprints) (ret graphql.Marshaler) {
2021-10-26 10:22:02 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricFootprints",
2021-10-26 10:22:02 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Footprints, nil
2021-10-26 10:22:02 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]schema.Float)
2021-10-26 10:22:02 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx, field.Selections, res)
2021-10-26 10:22:02 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricStatistics_avg(ctx context.Context, field graphql.CollectedField, obj *schema.MetricStatistics) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricStatistics",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Avg, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(float64)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2float64(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricStatistics_min(ctx context.Context, field graphql.CollectedField, obj *schema.MetricStatistics) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricStatistics",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Min, nil
2021-04-22 15:00:54 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(float64)
2021-04-22 15:00:54 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2float64(ctx, field.Selections, res)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _MetricStatistics_max(ctx context.Context, field graphql.CollectedField, obj *schema.MetricStatistics) (ret graphql.Marshaler) {
2021-04-22 15:00:54 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "MetricStatistics",
2021-04-22 15:00:54 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Max, nil
2021-04-07 09:19:21 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(float64)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2float64(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Mutation_createTag(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Mutation",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
2021-04-07 09:19:21 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
2021-12-17 15:49:22 +01:00
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Mutation_createTag_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
2021-04-07 09:19:21 +02:00
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Mutation().CreateTag(rctx, args["type"].(string), args["name"].(string))
})
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.Tag)
fc.Result = res
return ec.marshalNTag2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTag(ctx, field.Selections, res)
}
func (ec *executionContext) _Mutation_deleteTag(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Mutation",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Mutation_deleteTag_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.Mutation().DeleteTag(rctx, args["id"].(string))
})
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.(string)
fc.Result = res
return ec.marshalNID2string(ctx, field.Selections, res)
}
func (ec *executionContext) _Mutation_addTagsToJob(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Mutation",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Mutation_addTagsToJob_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.Mutation().AddTagsToJob(rctx, args["job"].(string), args["tagIds"].([]string))
})
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.Tag)
fc.Result = res
return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTagᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _Mutation_removeTagsFromJob(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Mutation",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Mutation_removeTagsFromJob_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.Mutation().RemoveTagsFromJob(rctx, args["job"].(string), args["tagIds"].([]string))
})
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.Tag)
fc.Result = res
return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTagᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _Mutation_updateConfiguration(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Mutation",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Mutation_updateConfiguration_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return ec.resolvers.Mutation().UpdateConfiguration(rctx, args["name"].(string), args["value"].(string))
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) _NodeMetric_name(ctx context.Context, field graphql.CollectedField, obj *model.NodeMetric) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "NodeMetric",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Name, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
func (ec *executionContext) _NodeMetric_data(ctx context.Context, field graphql.CollectedField, obj *model.NodeMetric) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "NodeMetric",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Data, 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.Float)
fc.Result = res
return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _NodeMetrics_id(ctx context.Context, field graphql.CollectedField, obj *model.NodeMetrics) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "NodeMetrics",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ID, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
func (ec *executionContext) _NodeMetrics_metrics(ctx context.Context, field graphql.CollectedField, obj *model.NodeMetrics) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "NodeMetrics",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Metrics, 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.([]*model.NodeMetric)
fc.Result = res
return ec.marshalNNodeMetric2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetricᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _Partition_name(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Partition",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Name, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
func (ec *executionContext) _Partition_processorType(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Partition",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ProcessorType, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
func (ec *executionContext) _Partition_socketsPerNode(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Partition",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.SocketsPerNode, nil
2021-04-07 09:19:21 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-04-22 15:00:54 +02:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-04-22 15:00:54 +02:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Partition_coresPerSocket(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Partition",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.CoresPerSocket, nil
2021-04-07 09:19:21 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-04-22 15:00:54 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Partition_threadsPerCore(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
2021-04-14 18:53:18 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Partition",
2021-04-14 18:53:18 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.ThreadsPerCore, nil
2021-04-14 18:53:18 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-14 18:53:18 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-14 18:53:18 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Partition_flopRateScalar(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
2021-04-14 18:53:18 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Partition",
2021-04-14 18:53:18 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.FlopRateScalar, nil
2021-04-14 18:53:18 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-14 18:53:18 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-14 18:53:18 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Partition_flopRateSimd(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
2021-04-14 18:53:18 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Partition",
2021-04-14 18:53:18 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.FlopRateSimd, nil
2021-04-14 18:53:18 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(int)
2021-04-14 18:53:18 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNInt2int(ctx, field.Selections, res)
2021-04-14 18:53:18 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Partition_memoryBandwidth(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Partition",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.MemoryBandwidth, nil
2021-04-07 09:19:21 +02:00
})
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)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Partition_topology(ctx context.Context, field graphql.CollectedField, obj *model.Partition) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Partition",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Topology, nil
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*model.Topology)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNTopology2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐTopology(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_clusters(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
2021-04-07 09:19:21 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().Clusters(rctx)
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.Cluster)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNCluster2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐClusterᚄ(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_tags(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
2021-04-07 09:19:21 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().Tags(rctx)
2021-04-07 09:19:21 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*schema.Tag)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTagᚄ(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_job(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
2021-04-07 09:19:21 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
2021-12-17 15:49:22 +01:00
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Query_job_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
2021-04-07 09:19:21 +02:00
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().Job(rctx, args["id"].(string))
2021-04-07 09:19:21 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*schema.Job)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJob(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_jobMetrics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
2021-12-17 15:49:22 +01:00
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Query_jobMetrics_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-20 10:48:58 +01:00
return ec.resolvers.Query().JobMetrics(rctx, args["id"].(string), args["metrics"].([]string), args["scopes"].([]schema.MetricScope))
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.JobMetricWithName)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNJobMetricWithName2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobMetricWithNameᚄ(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_jobsFootprints(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-05-21 09:30:15 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-05-21 09:30:15 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
2021-05-21 09:30:15 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
2021-12-17 15:49:22 +01:00
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Query_jobsFootprints_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
2021-05-21 09:30:15 +02:00
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().JobsFootprints(rctx, args["filter"].([]*model.JobFilter), args["metrics"].([]string))
2021-05-21 09:30:15 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.MetricFootprints)
2021-05-21 09:30:15 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNMetricFootprints2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricFootprints(ctx, field.Selections, res)
2021-05-21 09:30:15 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_jobs(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-05-21 09:30:15 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-05-21 09:30:15 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: true,
IsResolver: true,
2021-05-21 09:30:15 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
2021-12-17 15:49:22 +01:00
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field_Query_jobs_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
2021-05-21 09:30:15 +02:00
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().Jobs(rctx, args["filter"].([]*model.JobFilter), args["page"].(*model.PageRequest), args["order"].(*model.OrderByInput))
2021-05-21 09:30:15 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*model.JobResultList)
2021-05-21 09:30:15 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNJobResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobResultList(ctx, field.Selections, res)
2021-05-21 09:30:15 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_jobsStatistics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-05-21 09:30:15 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-05-21 09:30:15 +02:00
Field: field,
Args: nil,
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
2021-12-17 15:49:22 +01:00
args, err := ec.field_Query_jobsStatistics_args(ctx, rawArgs)
2021-05-21 09:30:15 +02:00
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().JobsStatistics(rctx, args["filter"].([]*model.JobFilter), args["groupBy"].(*model.Aggregate))
2021-05-21 09:30:15 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.JobsStatistics)
2021-05-21 09:30:15 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNJobsStatistics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobsStatisticsᚄ(ctx, field.Selections, res)
2021-05-21 09:30:15 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_rooflineHeatmap(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-05-21 09:30:15 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-05-21 09:30:15 +02:00
Field: field,
Args: nil,
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
2021-12-17 15:49:22 +01:00
args, err := ec.field_Query_rooflineHeatmap_args(ctx, rawArgs)
2021-05-21 09:30:15 +02:00
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().RooflineHeatmap(rctx, args["filter"].([]*model.JobFilter), args["rows"].(int), args["cols"].(int), args["minX"].(float64), args["minY"].(float64), args["maxX"].(float64), args["maxY"].(float64))
2021-05-21 09:30:15 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.([][]float64)
2021-05-21 09:30:15 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNFloat2ᚕᚕfloat64ᚄ(ctx, field.Selections, res)
2021-05-21 09:30:15 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query_nodeMetrics(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
IsMethod: true,
IsResolver: true,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
2021-12-17 15:49:22 +01:00
args, err := ec.field_Query_nodeMetrics_args(ctx, rawArgs)
2021-09-23 11:45:20 +02:00
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.resolvers.Query().NodeMetrics(rctx, args["cluster"].(string), args["nodes"].([]string), args["metrics"].([]string), args["from"].(time.Time), args["to"].(time.Time))
2021-09-23 11:45:20 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-10-26 10:22:02 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-09-23 11:45:20 +02:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.NodeMetrics)
2021-09-23 11:45:20 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNNodeMetrics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetricsᚄ(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
2021-04-22 15:00:54 +02:00
IsMethod: true,
2021-12-17 15:49:22 +01:00
IsResolver: false,
2021-04-07 09:19:21 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
2021-10-26 10:22:02 +02:00
rawArgs := field.ArgumentMap(ec.Variables)
2021-12-17 15:49:22 +01:00
args, err := ec.field_Query___type_args(ctx, rawArgs)
2021-10-26 10:22:02 +02:00
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
2021-04-07 09:19:21 +02:00
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.introspectType(args["name"].(string))
2021-04-07 09:19:21 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*introspection.Type)
2021-04-07 09:19:21 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Query",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
IsMethod: true,
2021-12-17 15:49:22 +01:00
IsResolver: false,
2021-03-31 08:50:53 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return ec.introspectSchema()
2021-03-31 08:50:53 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.(*introspection.Schema)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Resource_hostname(ctx context.Context, field graphql.CollectedField, obj *schema.Resource) (ret graphql.Marshaler) {
2021-12-09 16:25:48 +01:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Resource",
2021-12-09 16:25:48 +01:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Hostname, nil
2021-12-09 16:25:48 +01:00
})
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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Resource_hwthreads(ctx context.Context, field graphql.CollectedField, obj *schema.Resource) (ret graphql.Marshaler) {
2021-12-09 16:25:48 +01:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Resource",
2021-12-09 16:25:48 +01:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.HWThreads, nil
2021-12-09 16:25:48 +01:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-17 15:49:22 +01:00
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.([]int)
2021-12-17 15:49:22 +01:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalOInt2ᚕintᚄ(ctx, field.Selections, res)
2021-12-17 15:49:22 +01:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Resource_accelerators(ctx context.Context, field graphql.CollectedField, obj *schema.Resource) (ret graphql.Marshaler) {
2021-12-17 15:49:22 +01:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
2021-12-09 16:25:48 +01:00
}
2021-12-17 15:49:22 +01:00
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Resource",
2021-12-17 15:49:22 +01:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Accelerators, nil
2021-12-17 15:49:22 +01:00
})
if err != nil {
ec.Error(ctx, err)
2021-12-09 16:25:48 +01:00
return graphql.Null
}
2021-12-17 15:49:22 +01:00
if resTmp == nil {
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.([]int)
2021-12-09 16:25:48 +01:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalOInt2ᚕintᚄ(ctx, field.Selections, res)
2021-12-09 16:25:48 +01:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Resource_configuration(ctx context.Context, field graphql.CollectedField, obj *schema.Resource) (ret graphql.Marshaler) {
2021-12-09 16:25:48 +01:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Resource",
2021-12-09 16:25:48 +01:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Configuration, nil
2021-12-09 16:25:48 +01:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.(string)
2021-12-09 16:25:48 +01:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalOString2string(ctx, field.Selections, res)
2021-12-09 16:25:48 +01:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Series_hostname(ctx context.Context, field graphql.CollectedField, obj *schema.Series) (ret graphql.Marshaler) {
2021-12-09 16:25:48 +01:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Series",
2021-12-09 16:25:48 +01:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Hostname, nil
2021-12-09 16:25:48 +01:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2022-01-07 09:44:34 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-12-09 16:25:48 +01:00
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.(string)
2021-12-09 16:25:48 +01:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
2021-12-09 16:25:48 +01:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Series_id(ctx context.Context, field graphql.CollectedField, obj *schema.Series) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Series",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-03-31 08:50:53 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Id, nil
2021-03-31 08:50:53 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.(*int)
2021-03-31 08:50:53 +02:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalOInt2ᚖint(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Series_statistics(ctx context.Context, field graphql.CollectedField, obj *schema.Series) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Series",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-03-31 08:50:53 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Statistics, nil
2021-03-31 08:50:53 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.(*schema.MetricStatistics)
2021-03-31 08:50:53 +02:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalOMetricStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricStatistics(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _Series_data(ctx context.Context, field graphql.CollectedField, obj *schema.Series) (ret graphql.Marshaler) {
2021-04-07 09:19:21 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "Series",
2021-04-07 09:19:21 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-04-07 09:19:21 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Data, nil
2021-04-07 09:19:21 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-12-17 15:49:22 +01:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-04-07 09:19:21 +02:00
return graphql.Null
}
2022-01-07 09:44:34 +01:00
res := resTmp.([]schema.Float)
2021-04-07 09:19:21 +02:00
fc.Result = res
2022-01-07 09:44:34 +01:00
return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx, field.Selections, res)
2021-04-07 09:19:21 +02:00
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) _StatsSeries_mean(ctx context.Context, field graphql.CollectedField, obj *schema.StatsSeries) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2022-01-07 09:44:34 +01:00
Object: "StatsSeries",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-09-23 11:45:20 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2022-01-07 09:44:34 +01:00
return obj.Mean, nil
2021-09-23 11:45:20 +02:00
})
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
}
2022-01-07 09:44:34 +01:00
res := resTmp.([]schema.Float)
fc.Result = res
return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _StatsSeries_min(ctx context.Context, field graphql.CollectedField, obj *schema.StatsSeries) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "StatsSeries",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Min, 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.Float)
fc.Result = res
return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _StatsSeries_max(ctx context.Context, field graphql.CollectedField, obj *schema.StatsSeries) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "StatsSeries",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Max, 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.Float)
fc.Result = res
return ec.marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) _Tag_id(ctx context.Context, field graphql.CollectedField, obj *schema.Tag) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Tag",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.ID, 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.(int64)
fc.Result = res
return ec.marshalNID2int64(ctx, field.Selections, res)
}
func (ec *executionContext) _Tag_type(ctx context.Context, field graphql.CollectedField, obj *schema.Tag) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "Tag",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Type, 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.(string)
2021-09-23 11:45:20 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Tag_name(ctx context.Context, field graphql.CollectedField, obj *schema.Tag) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Tag",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-09-23 11:45:20 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Name, nil
2021-09-23 11:45:20 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(string)
2021-09-23 11:45:20 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNString2string(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _TimeRangeOutput_from(ctx context.Context, field graphql.CollectedField, obj *model.TimeRangeOutput) (ret graphql.Marshaler) {
2021-04-14 18:53:18 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "TimeRangeOutput",
2021-04-14 18:53:18 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-04-14 18:53:18 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.From, nil
})
2021-04-14 18:53:18 +02:00
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(time.Time)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _TimeRangeOutput_to(ctx context.Context, field graphql.CollectedField, obj *model.TimeRangeOutput) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "TimeRangeOutput",
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
2021-04-14 18:53:18 +02:00
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.To, nil
2021-04-14 18:53:18 +02:00
})
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
}
2021-12-17 15:49:22 +01:00
res := resTmp.(time.Time)
2021-04-14 18:53:18 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res)
2021-04-14 18:53:18 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Topology_node(ctx context.Context, field graphql.CollectedField, obj *model.Topology) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Topology",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-09-23 11:45:20 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Node, nil
2021-09-23 11:45:20 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]int)
2021-09-23 11:45:20 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚕintᚄ(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Topology_socket(ctx context.Context, field graphql.CollectedField, obj *model.Topology) (ret graphql.Marshaler) {
2021-12-09 16:25:48 +01:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Topology",
2021-12-09 16:25:48 +01:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
IsResolver: false,
2021-12-09 16:25:48 +01:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Socket, nil
2021-12-09 16:25:48 +01:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([][]int)
2021-12-09 16:25:48 +01:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚕᚕintᚄ(ctx, field.Selections, res)
2021-12-09 16:25:48 +01:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Topology_memoryDomain(ctx context.Context, field graphql.CollectedField, obj *model.Topology) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Topology",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
2021-03-31 08:50:53 +02:00
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.MemoryDomain, nil
2021-03-31 08:50:53 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([][]int)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚕᚕintᚄ(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Topology_die(ctx context.Context, field graphql.CollectedField, obj *model.Topology) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Topology",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-12-17 15:49:22 +01:00
IsMethod: false,
2021-03-31 08:50:53 +02:00
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Die, nil
2021-03-31 08:50:53 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([][]int)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚕᚕintᚄ(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Topology_core(ctx context.Context, field graphql.CollectedField, obj *model.Topology) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Topology",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Core, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([][]int)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOInt2ᚕᚕintᚄ(ctx, field.Selections, res)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Topology_accelerators(ctx context.Context, field graphql.CollectedField, obj *model.Topology) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-12-17 15:49:22 +01:00
Object: "Topology",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-12-17 15:49:22 +01:00
return obj.Accelerators, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
res := resTmp.([]*model.Accelerator)
fc.Result = res
2021-12-17 15:49:22 +01:00
return ec.marshalOAccelerator2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐAcceleratorᚄ(ctx, field.Selections, res)
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Directive",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.Name, nil
2021-09-23 11:45:20 +02:00
})
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.(string)
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalNString2string(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Directive",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.Description, nil
2021-09-23 11:45:20 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-10-26 10:22:02 +02:00
res := resTmp.(string)
2021-09-23 11:45:20 +02:00
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalOString2string(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Directive",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.Locations, nil
2021-09-23 11:45:20 +02:00
})
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
}
2021-10-26 10:22:02 +02:00
res := resTmp.([]string)
2021-09-23 11:45:20 +02:00
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {
2021-09-23 11:45:20 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Directive",
2021-09-23 11:45:20 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.Args, nil
2021-09-23 11:45:20 +02:00
})
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
}
2021-10-26 10:22:02 +02:00
res := resTmp.([]introspection.InputValue)
2021-09-23 11:45:20 +02:00
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__EnumValue",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Name, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__EnumValue",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Description, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(string)
fc.Result = res
return ec.marshalOString2string(ctx, field.Selections, res)
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__EnumValue",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-10-26 10:22:02 +02:00
IsMethod: true,
2021-03-31 08:50:53 +02:00
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.IsDeprecated(), nil
2021-03-31 08:50:53 +02:00
})
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
}
2021-10-26 10:22:02 +02:00
res := resTmp.(bool)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__EnumValue",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-10-26 10:22:02 +02:00
IsMethod: true,
2021-03-31 08:50:53 +02:00
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.DeprecationReason(), nil
2021-03-31 08:50:53 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
2021-10-26 10:22:02 +02:00
res := resTmp.(*string)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Field",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Name, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Field",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Description, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(string)
fc.Result = res
return ec.marshalOString2string(ctx, field.Selections, res)
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Field",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-10-26 10:22:02 +02:00
IsMethod: false,
2021-03-31 08:50:53 +02:00
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.Args, nil
2021-03-31 08:50:53 +02:00
})
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
}
2021-10-26 10:22:02 +02:00
res := resTmp.([]introspection.InputValue)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
2021-10-26 10:22:02 +02:00
Object: "__Field",
2021-03-31 08:50:53 +02:00
Field: field,
Args: nil,
2021-10-26 10:22:02 +02:00
IsMethod: false,
2021-03-31 08:50:53 +02:00
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.Type, nil
2021-03-31 08:50:53 +02:00
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
2021-10-26 10:22:02 +02:00
if !graphql.HasFieldError(ctx, fc) {
ec.Errorf(ctx, "must not be null")
}
2021-03-31 08:50:53 +02:00
return graphql.Null
}
2021-10-26 10:22:02 +02:00
res := resTmp.(*introspection.Type)
2021-03-31 08:50:53 +02:00
fc.Result = res
2021-10-26 10:22:02 +02:00
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
2021-03-31 08:50:53 +02:00
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Field",
Field: field,
Args: nil,
2021-10-26 10:22:02 +02:00
IsMethod: true,
2021-03-31 08:50:53 +02:00
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
2021-10-26 10:22:02 +02:00
return obj.IsDeprecated(), nil
2021-03-31 08:50:53 +02:00
})
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
}
2021-10-26 10:22:02 +02:00
res := resTmp.(bool)
2021-03-31 08:50:53 +02:00
fc.Result = res
return ec.marshalNBoolean2bool(ctx, field.Selections, res)
}
func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Field",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.DeprecationReason(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__InputValue",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Name, 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.(string)
fc.Result = res
return ec.marshalNString2string(ctx, field.Selections, res)
}
func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__InputValue",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Description, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(string)
fc.Result = res
return ec.marshalOString2string(ctx, field.Selections, res)
}
func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__InputValue",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Type, 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.(*introspection.Type)
fc.Result = res
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}
func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__InputValue",
Field: field,
Args: nil,
IsMethod: false,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.DefaultValue, nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Schema",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Types(), 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.([]introspection.Type)
fc.Result = res
return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Schema",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.QueryType(), 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.(*introspection.Type)
fc.Result = res
return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}
func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Schema",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.MutationType(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*introspection.Type)
fc.Result = res
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}
func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Schema",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.SubscriptionType(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*introspection.Type)
fc.Result = res
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
}
func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Schema",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Directives(), 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.([]introspection.Directive)
fc.Result = res
return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Kind(), 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.(string)
fc.Result = res
return ec.marshalN__TypeKind2string(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Name(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*string)
fc.Result = res
return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Description(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(string)
fc.Result = res
return ec.marshalOString2string(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field___Type_fields_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Fields(args["includeDeprecated"].(bool)), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.([]introspection.Field)
fc.Result = res
return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.Interfaces(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.([]introspection.Type)
fc.Result = res
return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.PossibleTypes(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.([]introspection.Type)
fc.Result = res
return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
rawArgs := field.ArgumentMap(ec.Variables)
args, err := ec.field___Type_enumValues_args(ctx, rawArgs)
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
fc.Args = args
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.EnumValues(args["includeDeprecated"].(bool)), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.([]introspection.EnumValue)
fc.Result = res
return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)
}
func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.InputFields(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.([]introspection.InputValue)
fc.Result = res
return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = graphql.Null
2021-03-31 08:50:53 +02:00
}
}()
fc := &graphql.FieldContext{
Object: "__Type",
Field: field,
Args: nil,
IsMethod: true,
IsResolver: false,
2021-03-31 08:50:53 +02:00
}
ctx = graphql.WithFieldContext(ctx, fc)
resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
ctx = rctx // use context from middleware stack in children
return obj.OfType(), nil
})
if err != nil {
ec.Error(ctx, err)
return graphql.Null
}
if resTmp == nil {
return graphql.Null
}
res := resTmp.(*introspection.Type)
fc.Result = res
return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)
2021-03-31 08:50:53 +02:00
}
// endregion **************************** field.gotpl *****************************
// region **************************** input.gotpl *****************************
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalInputFloatRange(ctx context.Context, obj interface{}) (model.FloatRange, error) {
var it model.FloatRange
var asMap = obj.(map[string]interface{})
for k, v := range asMap {
switch k {
case "from":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("from"))
it.From, err = ec.unmarshalNFloat2float64(ctx, v)
if err != nil {
return it, err
}
case "to":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("to"))
it.To, err = ec.unmarshalNFloat2float64(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputIntRange(ctx context.Context, obj interface{}) (model.IntRange, error) {
var it model.IntRange
var asMap = obj.(map[string]interface{})
for k, v := range asMap {
switch k {
case "from":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("from"))
it.From, err = ec.unmarshalNInt2int(ctx, v)
if err != nil {
return it, err
}
case "to":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("to"))
it.To, err = ec.unmarshalNInt2int(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputJobFilter(ctx context.Context, obj interface{}) (model.JobFilter, error) {
var it model.JobFilter
var asMap = obj.(map[string]interface{})
for k, v := range asMap {
switch k {
case "tags":
2021-04-21 10:12:19 +02:00
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("tags"))
it.Tags, err = ec.unmarshalOID2ᚕstringᚄ(ctx, v)
2021-04-21 10:12:19 +02:00
if err != nil {
return it, err
}
2021-03-31 08:50:53 +02:00
case "jobId":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("jobId"))
it.JobID, err = ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐStringInput(ctx, v)
if err != nil {
return it, err
}
case "user":
2021-03-31 08:50:53 +02:00
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("user"))
it.User, err = ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐStringInput(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
case "project":
2021-03-31 08:50:53 +02:00
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("project"))
it.Project, err = ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐStringInput(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
case "cluster":
2021-03-31 08:50:53 +02:00
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("cluster"))
it.Cluster, err = ec.unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐStringInput(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
case "duration":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("duration"))
it.Duration, err = ec.unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐIntRange(ctx, v)
if err != nil {
return it, err
}
case "numNodes":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("numNodes"))
it.NumNodes, err = ec.unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐIntRange(ctx, v)
if err != nil {
return it, err
}
case "startTime":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("startTime"))
it.StartTime, err = ec.unmarshalOTimeRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐTimeRange(ctx, v)
if err != nil {
return it, err
}
2021-12-17 15:49:22 +01:00
case "state":
2021-03-31 08:50:53 +02:00
var err error
2021-12-17 15:49:22 +01:00
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("state"))
it.State, err = ec.unmarshalOJobState2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobStateᚄ(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
case "flopsAnyAvg":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("flopsAnyAvg"))
it.FlopsAnyAvg, err = ec.unmarshalOFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐFloatRange(ctx, v)
if err != nil {
return it, err
}
case "memBwAvg":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("memBwAvg"))
it.MemBwAvg, err = ec.unmarshalOFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐFloatRange(ctx, v)
if err != nil {
return it, err
}
case "loadAvg":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("loadAvg"))
it.LoadAvg, err = ec.unmarshalOFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐFloatRange(ctx, v)
if err != nil {
return it, err
}
case "memUsedMax":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("memUsedMax"))
it.MemUsedMax, err = ec.unmarshalOFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐFloatRange(ctx, v)
if err != nil {
return it, err
}
2021-03-31 08:50:53 +02:00
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputOrderByInput(ctx context.Context, obj interface{}) (model.OrderByInput, error) {
var it model.OrderByInput
var asMap = obj.(map[string]interface{})
if _, present := asMap["order"]; !present {
asMap["order"] = "ASC"
}
for k, v := range asMap {
switch k {
case "field":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("field"))
it.Field, err = ec.unmarshalNString2string(ctx, v)
if err != nil {
return it, err
}
case "order":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("order"))
2021-10-26 10:22:02 +02:00
it.Order, err = ec.unmarshalNSortDirectionEnum2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐSortDirectionEnum(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputPageRequest(ctx context.Context, obj interface{}) (model.PageRequest, error) {
var it model.PageRequest
var asMap = obj.(map[string]interface{})
for k, v := range asMap {
switch k {
case "itemsPerPage":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("itemsPerPage"))
2021-09-23 11:45:20 +02:00
it.ItemsPerPage, err = ec.unmarshalNInt2int(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
case "page":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("page"))
2021-09-23 11:45:20 +02:00
it.Page, err = ec.unmarshalNInt2int(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputStringInput(ctx context.Context, obj interface{}) (model.StringInput, error) {
var it model.StringInput
var asMap = obj.(map[string]interface{})
for k, v := range asMap {
switch k {
case "eq":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("eq"))
it.Eq, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "contains":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("contains"))
it.Contains, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "startsWith":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("startsWith"))
it.StartsWith, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
case "endsWith":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("endsWith"))
it.EndsWith, err = ec.unmarshalOString2ᚖstring(ctx, v)
if err != nil {
return it, err
}
}
}
return it, nil
}
func (ec *executionContext) unmarshalInputTimeRange(ctx context.Context, obj interface{}) (model.TimeRange, error) {
var it model.TimeRange
var asMap = obj.(map[string]interface{})
for k, v := range asMap {
switch k {
case "from":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("from"))
2021-10-26 10:22:02 +02:00
it.From, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
case "to":
var err error
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("to"))
2021-10-26 10:22:02 +02:00
it.To, err = ec.unmarshalOTime2ᚖtimeᚐTime(ctx, v)
2021-03-31 08:50:53 +02:00
if err != nil {
return it, err
}
}
}
return it, nil
}
// endregion **************************** input.gotpl *****************************
// region ************************** interface.gotpl ***************************
// endregion ************************** interface.gotpl ***************************
// region **************************** object.gotpl ****************************
var acceleratorImplementors = []string{"Accelerator"}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Accelerator(ctx context.Context, sel ast.SelectionSet, obj *model.Accelerator) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, acceleratorImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Accelerator")
2021-12-17 15:49:22 +01:00
case "id":
out.Values[i] = ec._Accelerator_id(ctx, field, obj)
if out.Values[i] == graphql.Null {
2021-12-17 15:49:22 +01:00
invalids++
}
2021-12-17 15:49:22 +01:00
case "type":
out.Values[i] = ec._Accelerator_type(ctx, field, obj)
if out.Values[i] == graphql.Null {
2021-12-17 15:49:22 +01:00
invalids++
}
case "model":
out.Values[i] = ec._Accelerator_model(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
2021-04-07 09:19:21 +02:00
}
2021-04-22 15:00:54 +02:00
var clusterImplementors = []string{"Cluster"}
func (ec *executionContext) _Cluster(ctx context.Context, sel ast.SelectionSet, obj *model.Cluster) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, clusterImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Cluster")
2021-12-17 15:49:22 +01:00
case "name":
out.Values[i] = ec._Cluster_name(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
2021-10-26 10:22:02 +02:00
invalids++
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
case "metricConfig":
out.Values[i] = ec._Cluster_metricConfig(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
2021-10-26 10:22:02 +02:00
invalids++
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
case "filterRanges":
out.Values[i] = ec._Cluster_filterRanges(ctx, field, obj)
if out.Values[i] == graphql.Null {
2021-10-26 10:22:02 +02:00
invalids++
}
2021-12-17 15:49:22 +01:00
case "partitions":
out.Values[i] = ec._Cluster_partitions(ctx, field, obj)
2021-10-26 10:22:02 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var filterRangesImplementors = []string{"FilterRanges"}
func (ec *executionContext) _FilterRanges(ctx context.Context, sel ast.SelectionSet, obj *model.FilterRanges) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, filterRangesImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("FilterRanges")
case "duration":
out.Values[i] = ec._FilterRanges_duration(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "numNodes":
out.Values[i] = ec._FilterRanges_numNodes(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "startTime":
out.Values[i] = ec._FilterRanges_startTime(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-04-07 09:19:21 +02:00
var histoPointImplementors = []string{"HistoPoint"}
func (ec *executionContext) _HistoPoint(ctx context.Context, sel ast.SelectionSet, obj *model.HistoPoint) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, histoPointImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("HistoPoint")
case "count":
out.Values[i] = ec._HistoPoint_count(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "value":
out.Values[i] = ec._HistoPoint_value(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var intRangeOutputImplementors = []string{"IntRangeOutput"}
func (ec *executionContext) _IntRangeOutput(ctx context.Context, sel ast.SelectionSet, obj *model.IntRangeOutput) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, intRangeOutputImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("IntRangeOutput")
case "from":
out.Values[i] = ec._IntRangeOutput_from(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "to":
out.Values[i] = ec._IntRangeOutput_to(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-04-07 09:19:21 +02:00
var jobImplementors = []string{"Job"}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) _Job(ctx context.Context, sel ast.SelectionSet, obj *schema.Job) graphql.Marshaler {
2021-04-07 09:19:21 +02:00
fields := graphql.CollectFields(ec.OperationContext, sel, jobImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Job")
2021-12-17 15:49:22 +01:00
case "id":
out.Values[i] = ec._Job_id(ctx, field, obj)
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "jobId":
out.Values[i] = ec._Job_jobId(ctx, field, obj)
2021-04-07 09:19:21 +02:00
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
case "user":
out.Values[i] = ec._Job_user(ctx, field, obj)
2021-04-07 09:19:21 +02:00
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
case "project":
out.Values[i] = ec._Job_project(ctx, field, obj)
2021-04-07 09:19:21 +02:00
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
case "cluster":
out.Values[i] = ec._Job_cluster(ctx, field, obj)
2021-04-07 09:19:21 +02:00
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
case "startTime":
out.Values[i] = ec._Job_startTime(ctx, field, obj)
2021-04-07 09:19:21 +02:00
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
case "duration":
out.Values[i] = ec._Job_duration(ctx, field, obj)
2021-04-07 09:19:21 +02:00
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
case "numNodes":
out.Values[i] = ec._Job_numNodes(ctx, field, obj)
2021-04-07 09:19:21 +02:00
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
case "numHWThreads":
out.Values[i] = ec._Job_numHWThreads(ctx, field, obj)
2021-10-26 10:22:02 +02:00
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "numAcc":
out.Values[i] = ec._Job_numAcc(ctx, field, obj)
if out.Values[i] == graphql.Null {
2021-04-21 10:12:19 +02:00
atomic.AddUint32(&invalids, 1)
}
case "SMT":
out.Values[i] = ec._Job_SMT(ctx, field, obj)
2021-10-26 10:22:02 +02:00
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "exclusive":
out.Values[i] = ec._Job_exclusive(ctx, field, obj)
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "partition":
out.Values[i] = ec._Job_partition(ctx, field, obj)
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "arrayJobId":
out.Values[i] = ec._Job_arrayJobId(ctx, field, obj)
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "monitoringStatus":
out.Values[i] = ec._Job_monitoringStatus(ctx, field, obj)
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "state":
out.Values[i] = ec._Job_state(ctx, field, obj)
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-12-17 15:49:22 +01:00
case "tags":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._Job_tags(ctx, field, obj)
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
case "resources":
2022-01-07 09:44:34 +01:00
out.Values[i] = ec._Job_resources(ctx, field, obj)
if out.Values[i] == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
2021-04-07 09:19:21 +02:00
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
2021-03-31 08:50:53 +02:00
}
2021-04-07 09:19:21 +02:00
var jobMetricImplementors = []string{"JobMetric"}
2021-03-31 08:50:53 +02:00
2021-10-26 10:22:02 +02:00
func (ec *executionContext) _JobMetric(ctx context.Context, sel ast.SelectionSet, obj *schema.JobMetric) graphql.Marshaler {
2021-04-07 09:19:21 +02:00
fields := graphql.CollectFields(ec.OperationContext, sel, jobMetricImplementors)
2021-03-31 08:50:53 +02:00
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
2021-04-07 09:19:21 +02:00
out.Values[i] = graphql.MarshalString("JobMetric")
2021-12-17 15:49:22 +01:00
case "unit":
out.Values[i] = ec._JobMetric_unit(ctx, field, obj)
2021-03-31 08:50:53 +02:00
if out.Values[i] == graphql.Null {
2022-01-07 09:44:34 +01:00
invalids++
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
case "scope":
out.Values[i] = ec._JobMetric_scope(ctx, field, obj)
2021-03-31 08:50:53 +02:00
if out.Values[i] == graphql.Null {
2022-01-07 09:44:34 +01:00
invalids++
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
case "timestep":
out.Values[i] = ec._JobMetric_timestep(ctx, field, obj)
2021-03-31 08:50:53 +02:00
if out.Values[i] == graphql.Null {
2022-01-07 09:44:34 +01:00
invalids++
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
case "series":
out.Values[i] = ec._JobMetric_series(ctx, field, obj)
case "statisticsSeries":
2022-01-07 09:44:34 +01:00
out.Values[i] = ec._JobMetric_statisticsSeries(ctx, field, obj)
2021-04-07 09:19:21 +02:00
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var jobMetricWithNameImplementors = []string{"JobMetricWithName"}
func (ec *executionContext) _JobMetricWithName(ctx context.Context, sel ast.SelectionSet, obj *model.JobMetricWithName) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, jobMetricWithNameImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("JobMetricWithName")
case "name":
out.Values[i] = ec._JobMetricWithName_name(ctx, field, obj)
2021-03-31 08:50:53 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-20 10:48:58 +01:00
case "metric":
out.Values[i] = ec._JobMetricWithName_metric(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
2021-03-31 08:50:53 +02:00
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var jobResultListImplementors = []string{"JobResultList"}
func (ec *executionContext) _JobResultList(ctx context.Context, sel ast.SelectionSet, obj *model.JobResultList) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, jobResultListImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("JobResultList")
case "items":
out.Values[i] = ec._JobResultList_items(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "offset":
out.Values[i] = ec._JobResultList_offset(ctx, field, obj)
case "limit":
out.Values[i] = ec._JobResultList_limit(ctx, field, obj)
case "count":
out.Values[i] = ec._JobResultList_count(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var jobsStatisticsImplementors = []string{"JobsStatistics"}
func (ec *executionContext) _JobsStatistics(ctx context.Context, sel ast.SelectionSet, obj *model.JobsStatistics) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, jobsStatisticsImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("JobsStatistics")
2021-10-26 10:22:02 +02:00
case "id":
out.Values[i] = ec._JobsStatistics_id(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
2021-03-31 08:50:53 +02:00
case "totalJobs":
out.Values[i] = ec._JobsStatistics_totalJobs(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "shortJobs":
out.Values[i] = ec._JobsStatistics_shortJobs(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "totalWalltime":
out.Values[i] = ec._JobsStatistics_totalWalltime(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "totalCoreHours":
out.Values[i] = ec._JobsStatistics_totalCoreHours(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "histWalltime":
out.Values[i] = ec._JobsStatistics_histWalltime(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "histNumNodes":
out.Values[i] = ec._JobsStatistics_histNumNodes(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-04-22 15:00:54 +02:00
var metricConfigImplementors = []string{"MetricConfig"}
func (ec *executionContext) _MetricConfig(ctx context.Context, sel ast.SelectionSet, obj *model.MetricConfig) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, metricConfigImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("MetricConfig")
2021-12-17 15:49:22 +01:00
case "name":
out.Values[i] = ec._MetricConfig_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "unit":
out.Values[i] = ec._MetricConfig_unit(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-17 15:49:22 +01:00
case "scope":
out.Values[i] = ec._MetricConfig_scope(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-17 15:49:22 +01:00
case "timestep":
out.Values[i] = ec._MetricConfig_timestep(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-20 10:48:58 +01:00
case "peak":
out.Values[i] = ec._MetricConfig_peak(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-20 10:48:58 +01:00
case "normal":
out.Values[i] = ec._MetricConfig_normal(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-20 10:48:58 +01:00
case "caution":
out.Values[i] = ec._MetricConfig_caution(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-20 10:48:58 +01:00
case "alert":
out.Values[i] = ec._MetricConfig_alert(ctx, field, obj)
2021-04-22 15:00:54 +02:00
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-10-26 10:22:02 +02:00
var metricFootprintsImplementors = []string{"MetricFootprints"}
func (ec *executionContext) _MetricFootprints(ctx context.Context, sel ast.SelectionSet, obj *model.MetricFootprints) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, metricFootprintsImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("MetricFootprints")
case "name":
out.Values[i] = ec._MetricFootprints_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "footprints":
out.Values[i] = ec._MetricFootprints_footprints(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-12-17 15:49:22 +01:00
var metricStatisticsImplementors = []string{"MetricStatistics"}
func (ec *executionContext) _MetricStatistics(ctx context.Context, sel ast.SelectionSet, obj *schema.MetricStatistics) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, metricStatisticsImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("MetricStatistics")
case "avg":
out.Values[i] = ec._MetricStatistics_avg(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "min":
out.Values[i] = ec._MetricStatistics_min(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "max":
out.Values[i] = ec._MetricStatistics_max(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-05-21 09:30:15 +02:00
var mutationImplementors = []string{"Mutation"}
func (ec *executionContext) _Mutation(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, mutationImplementors)
ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
Object: "Mutation",
})
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Mutation")
case "createTag":
out.Values[i] = ec._Mutation_createTag(ctx, field)
if out.Values[i] == graphql.Null {
invalids++
}
case "deleteTag":
out.Values[i] = ec._Mutation_deleteTag(ctx, field)
if out.Values[i] == graphql.Null {
invalids++
}
case "addTagsToJob":
out.Values[i] = ec._Mutation_addTagsToJob(ctx, field)
if out.Values[i] == graphql.Null {
invalids++
}
case "removeTagsFromJob":
out.Values[i] = ec._Mutation_removeTagsFromJob(ctx, field)
if out.Values[i] == graphql.Null {
invalids++
}
2021-09-23 11:45:20 +02:00
case "updateConfiguration":
out.Values[i] = ec._Mutation_updateConfiguration(ctx, field)
2021-05-21 09:30:15 +02:00
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-12-09 16:25:48 +01:00
var nodeMetricImplementors = []string{"NodeMetric"}
func (ec *executionContext) _NodeMetric(ctx context.Context, sel ast.SelectionSet, obj *model.NodeMetric) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, nodeMetricImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("NodeMetric")
case "name":
out.Values[i] = ec._NodeMetric_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "data":
out.Values[i] = ec._NodeMetric_data(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var nodeMetricsImplementors = []string{"NodeMetrics"}
func (ec *executionContext) _NodeMetrics(ctx context.Context, sel ast.SelectionSet, obj *model.NodeMetrics) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, nodeMetricsImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("NodeMetrics")
case "id":
out.Values[i] = ec._NodeMetrics_id(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "metrics":
out.Values[i] = ec._NodeMetrics_metrics(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-12-17 15:49:22 +01:00
var partitionImplementors = []string{"Partition"}
func (ec *executionContext) _Partition(ctx context.Context, sel ast.SelectionSet, obj *model.Partition) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, partitionImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Partition")
case "name":
out.Values[i] = ec._Partition_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "processorType":
out.Values[i] = ec._Partition_processorType(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "socketsPerNode":
out.Values[i] = ec._Partition_socketsPerNode(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "coresPerSocket":
out.Values[i] = ec._Partition_coresPerSocket(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "threadsPerCore":
out.Values[i] = ec._Partition_threadsPerCore(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "flopRateScalar":
out.Values[i] = ec._Partition_flopRateScalar(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "flopRateSimd":
out.Values[i] = ec._Partition_flopRateSimd(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "memoryBandwidth":
out.Values[i] = ec._Partition_memoryBandwidth(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "topology":
out.Values[i] = ec._Partition_topology(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-03-31 08:50:53 +02:00
var queryImplementors = []string{"Query"}
func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, queryImplementors)
ctx = graphql.WithFieldContext(ctx, &graphql.FieldContext{
Object: "Query",
})
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Query")
2021-04-22 15:00:54 +02:00
case "clusters":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._Query_clusters(ctx, field)
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-10-26 10:22:02 +02:00
case "tags":
2021-03-31 08:50:53 +02:00
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
2021-10-26 10:22:02 +02:00
res = ec._Query_tags(ctx, field)
2021-03-31 08:50:53 +02:00
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-10-26 10:22:02 +02:00
case "job":
2021-03-31 08:50:53 +02:00
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
2021-10-26 10:22:02 +02:00
res = ec._Query_job(ctx, field)
2021-03-31 08:50:53 +02:00
return res
})
case "jobMetrics":
2021-04-07 09:19:21 +02:00
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._Query_jobMetrics(ctx, field)
2021-04-07 09:19:21 +02:00
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-10-26 10:22:02 +02:00
case "jobsFootprints":
2021-09-23 11:45:20 +02:00
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
2021-10-26 10:22:02 +02:00
res = ec._Query_jobsFootprints(ctx, field)
2021-09-23 11:45:20 +02:00
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-10-26 10:22:02 +02:00
case "jobs":
2021-09-23 11:45:20 +02:00
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
2021-10-26 10:22:02 +02:00
res = ec._Query_jobs(ctx, field)
2021-09-23 11:45:20 +02:00
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-10-26 10:22:02 +02:00
case "jobsStatistics":
2021-04-14 18:53:18 +02:00
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
2021-10-26 10:22:02 +02:00
res = ec._Query_jobsStatistics(ctx, field)
2021-04-14 18:53:18 +02:00
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-10-26 10:22:02 +02:00
case "rooflineHeatmap":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
2021-10-26 10:22:02 +02:00
res = ec._Query_rooflineHeatmap(ctx, field)
2021-09-23 11:45:20 +02:00
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-12-09 16:25:48 +01:00
case "nodeMetrics":
field := field
out.Concurrently(i, func() (res graphql.Marshaler) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
}
}()
res = ec._Query_nodeMetrics(ctx, field)
if res == graphql.Null {
atomic.AddUint32(&invalids, 1)
}
return res
})
2021-03-31 08:50:53 +02:00
case "__type":
out.Values[i] = ec._Query___type(ctx, field)
case "__schema":
out.Values[i] = ec._Query___schema(ctx, field)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2022-01-07 09:44:34 +01:00
var resourceImplementors = []string{"Resource"}
func (ec *executionContext) _Resource(ctx context.Context, sel ast.SelectionSet, obj *schema.Resource) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, resourceImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Resource")
case "hostname":
out.Values[i] = ec._Resource_hostname(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "hwthreads":
out.Values[i] = ec._Resource_hwthreads(ctx, field, obj)
case "accelerators":
out.Values[i] = ec._Resource_accelerators(ctx, field, obj)
case "configuration":
out.Values[i] = ec._Resource_configuration(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-12-17 15:49:22 +01:00
var seriesImplementors = []string{"Series"}
func (ec *executionContext) _Series(ctx context.Context, sel ast.SelectionSet, obj *schema.Series) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, seriesImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Series")
case "hostname":
out.Values[i] = ec._Series_hostname(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "id":
out.Values[i] = ec._Series_id(ctx, field, obj)
case "statistics":
out.Values[i] = ec._Series_statistics(ctx, field, obj)
case "data":
out.Values[i] = ec._Series_data(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var statsSeriesImplementors = []string{"StatsSeries"}
func (ec *executionContext) _StatsSeries(ctx context.Context, sel ast.SelectionSet, obj *schema.StatsSeries) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, statsSeriesImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("StatsSeries")
case "mean":
out.Values[i] = ec._StatsSeries_mean(ctx, field, obj)
2022-01-07 09:44:34 +01:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-17 15:49:22 +01:00
case "min":
out.Values[i] = ec._StatsSeries_min(ctx, field, obj)
2022-01-07 09:44:34 +01:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-17 15:49:22 +01:00
case "max":
out.Values[i] = ec._StatsSeries_max(ctx, field, obj)
2022-01-07 09:44:34 +01:00
if out.Values[i] == graphql.Null {
invalids++
}
2021-12-17 15:49:22 +01:00
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var tagImplementors = []string{"Tag"}
func (ec *executionContext) _Tag(ctx context.Context, sel ast.SelectionSet, obj *schema.Tag) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, tagImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Tag")
case "id":
out.Values[i] = ec._Tag_id(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "type":
out.Values[i] = ec._Tag_type(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "name":
out.Values[i] = ec._Tag_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-09-23 11:45:20 +02:00
var timeRangeOutputImplementors = []string{"TimeRangeOutput"}
func (ec *executionContext) _TimeRangeOutput(ctx context.Context, sel ast.SelectionSet, obj *model.TimeRangeOutput) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, timeRangeOutputImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("TimeRangeOutput")
case "from":
out.Values[i] = ec._TimeRangeOutput_from(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "to":
out.Values[i] = ec._TimeRangeOutput_to(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-12-17 15:49:22 +01:00
var topologyImplementors = []string{"Topology"}
func (ec *executionContext) _Topology(ctx context.Context, sel ast.SelectionSet, obj *model.Topology) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, topologyImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("Topology")
case "node":
out.Values[i] = ec._Topology_node(ctx, field, obj)
case "socket":
out.Values[i] = ec._Topology_socket(ctx, field, obj)
case "memoryDomain":
out.Values[i] = ec._Topology_memoryDomain(ctx, field, obj)
case "die":
out.Values[i] = ec._Topology_die(ctx, field, obj)
case "core":
out.Values[i] = ec._Topology_core(ctx, field, obj)
case "accelerators":
out.Values[i] = ec._Topology_accelerators(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
2021-03-31 08:50:53 +02:00
var __DirectiveImplementors = []string{"__Directive"}
func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __DirectiveImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("__Directive")
case "name":
out.Values[i] = ec.___Directive_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "description":
out.Values[i] = ec.___Directive_description(ctx, field, obj)
case "locations":
out.Values[i] = ec.___Directive_locations(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "args":
out.Values[i] = ec.___Directive_args(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var __EnumValueImplementors = []string{"__EnumValue"}
func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __EnumValueImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("__EnumValue")
case "name":
out.Values[i] = ec.___EnumValue_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "description":
out.Values[i] = ec.___EnumValue_description(ctx, field, obj)
case "isDeprecated":
out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "deprecationReason":
out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var __FieldImplementors = []string{"__Field"}
func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __FieldImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("__Field")
case "name":
out.Values[i] = ec.___Field_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "description":
out.Values[i] = ec.___Field_description(ctx, field, obj)
case "args":
out.Values[i] = ec.___Field_args(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "type":
out.Values[i] = ec.___Field_type(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "isDeprecated":
out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "deprecationReason":
out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var __InputValueImplementors = []string{"__InputValue"}
func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __InputValueImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("__InputValue")
case "name":
out.Values[i] = ec.___InputValue_name(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "description":
out.Values[i] = ec.___InputValue_description(ctx, field, obj)
case "type":
out.Values[i] = ec.___InputValue_type(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "defaultValue":
out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var __SchemaImplementors = []string{"__Schema"}
func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __SchemaImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("__Schema")
case "types":
out.Values[i] = ec.___Schema_types(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "queryType":
out.Values[i] = ec.___Schema_queryType(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "mutationType":
out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)
case "subscriptionType":
out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)
case "directives":
out.Values[i] = ec.___Schema_directives(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
var __TypeImplementors = []string{"__Type"}
func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {
fields := graphql.CollectFields(ec.OperationContext, sel, __TypeImplementors)
out := graphql.NewFieldSet(fields)
var invalids uint32
for i, field := range fields {
switch field.Name {
case "__typename":
out.Values[i] = graphql.MarshalString("__Type")
case "kind":
out.Values[i] = ec.___Type_kind(ctx, field, obj)
if out.Values[i] == graphql.Null {
invalids++
}
case "name":
out.Values[i] = ec.___Type_name(ctx, field, obj)
case "description":
out.Values[i] = ec.___Type_description(ctx, field, obj)
case "fields":
out.Values[i] = ec.___Type_fields(ctx, field, obj)
case "interfaces":
out.Values[i] = ec.___Type_interfaces(ctx, field, obj)
case "possibleTypes":
out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)
case "enumValues":
out.Values[i] = ec.___Type_enumValues(ctx, field, obj)
case "inputFields":
out.Values[i] = ec.___Type_inputFields(ctx, field, obj)
case "ofType":
out.Values[i] = ec.___Type_ofType(ctx, field, obj)
default:
panic("unknown field " + strconv.Quote(field.Name))
}
}
out.Dispatch()
if invalids > 0 {
return graphql.Null
}
return out
}
// endregion **************************** object.gotpl ****************************
// region ***************************** type.gotpl *****************************
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNAccelerator2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐAccelerator(ctx context.Context, sel ast.SelectionSet, v *model.Accelerator) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._Accelerator(ctx, sel, v)
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
res, err := graphql.UnmarshalBoolean(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
res := graphql.MarshalBoolean(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
2021-04-22 15:00:54 +02:00
func (ec *executionContext) marshalNCluster2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐClusterᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.Cluster) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalNCluster2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐCluster(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalNCluster2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐCluster(ctx context.Context, sel ast.SelectionSet, v *model.Cluster) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._Cluster(ctx, sel, v)
}
func (ec *executionContext) marshalNFilterRanges2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐFilterRanges(ctx context.Context, sel ast.SelectionSet, v *model.FilterRanges) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._FilterRanges(ctx, sel, v)
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalNFloat2float64(ctx context.Context, v interface{}) (float64, error) {
res, err := graphql.UnmarshalFloat(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNFloat2float64(ctx context.Context, sel ast.SelectionSet, v float64) graphql.Marshaler {
res := graphql.MarshalFloat(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalNFloat2ᚕfloat64ᚄ(ctx context.Context, v interface{}) ([]float64, error) {
2021-09-23 11:45:20 +02:00
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
2021-10-26 10:22:02 +02:00
res := make([]float64, len(vSlice))
2021-09-23 11:45:20 +02:00
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2021-10-26 10:22:02 +02:00
res[i], err = ec.unmarshalNFloat2float64(ctx, vSlice[i])
2021-09-23 11:45:20 +02:00
if err != nil {
return nil, err
}
}
return res, nil
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalNFloat2ᚕfloat64ᚄ(ctx context.Context, sel ast.SelectionSet, v []float64) graphql.Marshaler {
2021-09-23 11:45:20 +02:00
ret := make(graphql.Array, len(v))
for i := range v {
2021-10-26 10:22:02 +02:00
ret[i] = ec.marshalNFloat2float64(ctx, sel, v[i])
2021-09-23 11:45:20 +02:00
}
return ret
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalNFloat2ᚕᚕfloat64ᚄ(ctx context.Context, v interface{}) ([][]float64, error) {
2021-04-07 09:19:21 +02:00
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
2021-10-26 10:22:02 +02:00
res := make([][]float64, len(vSlice))
2021-04-07 09:19:21 +02:00
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2021-10-26 10:22:02 +02:00
res[i], err = ec.unmarshalNFloat2ᚕfloat64ᚄ(ctx, vSlice[i])
2021-04-07 09:19:21 +02:00
if err != nil {
return nil, err
}
}
return res, nil
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalNFloat2ᚕᚕfloat64ᚄ(ctx context.Context, sel ast.SelectionSet, v [][]float64) graphql.Marshaler {
2021-04-07 09:19:21 +02:00
ret := make(graphql.Array, len(v))
for i := range v {
2021-10-26 10:22:02 +02:00
ret[i] = ec.marshalNFloat2ᚕfloat64ᚄ(ctx, sel, v[i])
2021-04-07 09:19:21 +02:00
}
return ret
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalNHistoPoint2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐHistoPointᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.HistoPoint) graphql.Marshaler {
2021-03-31 08:50:53 +02:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-10-26 10:22:02 +02:00
ret[i] = ec.marshalNHistoPoint2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐHistoPoint(ctx, sel, v[i])
2021-03-31 08:50:53 +02:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalNHistoPoint2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐHistoPoint(ctx context.Context, sel ast.SelectionSet, v *model.HistoPoint) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._HistoPoint(ctx, sel, v)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) unmarshalNID2int64(ctx context.Context, v interface{}) (int64, error) {
res, err := graphql.UnmarshalInt64(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNID2int64(ctx context.Context, sel ast.SelectionSet, v int64) graphql.Marshaler {
res := graphql.MarshalInt64(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
func (ec *executionContext) unmarshalNID2string(ctx context.Context, v interface{}) (string, error) {
res, err := graphql.UnmarshalID(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
res := graphql.MarshalID(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
2021-05-21 09:30:15 +02:00
func (ec *executionContext) unmarshalNID2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]string, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNID2string(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalNID2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNID2string(ctx, sel, v[i])
}
return ret
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalNInt2int(ctx context.Context, v interface{}) (int, error) {
res, err := graphql.UnmarshalInt(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {
res := graphql.MarshalInt(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) unmarshalNInt2int32(ctx context.Context, v interface{}) (int32, error) {
res, err := graphql.UnmarshalInt32(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNInt2int32(ctx context.Context, sel ast.SelectionSet, v int32) graphql.Marshaler {
res := graphql.MarshalInt32(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
func (ec *executionContext) unmarshalNInt2int64(ctx context.Context, v interface{}) (int64, error) {
res, err := graphql.UnmarshalInt64(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNInt2int64(ctx context.Context, sel ast.SelectionSet, v int64) graphql.Marshaler {
res := graphql.MarshalInt64(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
func (ec *executionContext) unmarshalNInt2ᚕintᚄ(ctx context.Context, v interface{}) ([]int, error) {
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]int, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNInt2int(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalNInt2ᚕintᚄ(ctx context.Context, sel ast.SelectionSet, v []int) graphql.Marshaler {
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNInt2int(ctx, sel, v[i])
}
return ret
}
func (ec *executionContext) marshalNIntRangeOutput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐIntRangeOutput(ctx context.Context, sel ast.SelectionSet, v *model.IntRangeOutput) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._IntRangeOutput(ctx, sel, v)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNJob2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Job) graphql.Marshaler {
2021-03-31 08:50:53 +02:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJob(ctx, sel, v[i])
2021-03-31 08:50:53 +02:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJob(ctx context.Context, sel ast.SelectionSet, v *schema.Job) graphql.Marshaler {
2021-10-26 10:22:02 +02:00
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._Job(ctx, sel, v)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalNJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilterᚄ(ctx context.Context, v interface{}) ([]*model.JobFilter, error) {
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]*model.JobFilter, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNJobFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilter(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) unmarshalNJobFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilter(ctx context.Context, v interface{}) (*model.JobFilter, error) {
res, err := ec.unmarshalInputJobFilter(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
2021-12-20 10:48:58 +01:00
func (ec *executionContext) marshalNJobMetric2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobMetric(ctx context.Context, sel ast.SelectionSet, v *schema.JobMetric) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._JobMetric(ctx, sel, v)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNJobMetricWithName2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobMetricWithNameᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.JobMetricWithName) graphql.Marshaler {
2021-04-07 09:19:21 +02:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNJobMetricWithName2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobMetricWithName(ctx, sel, v[i])
2021-04-07 09:19:21 +02:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNJobMetricWithName2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobMetricWithName(ctx context.Context, sel ast.SelectionSet, v *model.JobMetricWithName) graphql.Marshaler {
2021-10-26 10:22:02 +02:00
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
return ec._JobMetricWithName(ctx, sel, v)
2021-10-26 10:22:02 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNJobResultList2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobResultList(ctx context.Context, sel ast.SelectionSet, v model.JobResultList) graphql.Marshaler {
return ec._JobResultList(ctx, sel, &v)
}
func (ec *executionContext) marshalNJobResultList2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobResultList(ctx context.Context, sel ast.SelectionSet, v *model.JobResultList) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._JobResultList(ctx, sel, v)
}
func (ec *executionContext) unmarshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobState(ctx context.Context, v interface{}) (schema.JobState, error) {
var res schema.JobState
err := res.UnmarshalGQL(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobState(ctx context.Context, sel ast.SelectionSet, v schema.JobState) graphql.Marshaler {
return v
2021-10-26 10:22:02 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNJobsStatistics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobsStatisticsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.JobsStatistics) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNJobsStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobsStatistics(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNJobsStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobsStatistics(ctx context.Context, sel ast.SelectionSet, v *model.JobsStatistics) graphql.Marshaler {
2021-03-31 08:50:53 +02:00
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
return ec._JobsStatistics(ctx, sel, v)
2021-05-21 09:30:15 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNMetricConfig2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricConfigᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.MetricConfig) graphql.Marshaler {
2021-04-14 18:53:18 +02:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNMetricConfig2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricConfig(ctx, sel, v[i])
2021-04-14 18:53:18 +02:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNMetricConfig2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricConfig(ctx context.Context, sel ast.SelectionSet, v *model.MetricConfig) graphql.Marshaler {
2021-04-14 18:53:18 +02:00
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
return ec._MetricConfig(ctx, sel, v)
2021-04-14 18:53:18 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNMetricFootprints2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricFootprints(ctx context.Context, sel ast.SelectionSet, v []*model.MetricFootprints) graphql.Marshaler {
2021-10-26 10:22:02 +02:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalOMetricFootprints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricFootprints(ctx, sel, v[i])
2021-10-26 10:22:02 +02:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) unmarshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScope(ctx context.Context, v interface{}) (schema.MetricScope, error) {
var res schema.MetricScope
err := res.UnmarshalGQL(v)
return res, graphql.ErrorOnPath(ctx, err)
2021-03-31 08:50:53 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScope(ctx context.Context, sel ast.SelectionSet, v schema.MetricScope) graphql.Marshaler {
return v
}
func (ec *executionContext) marshalNNodeMetric2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetricᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.NodeMetric) graphql.Marshaler {
2021-10-26 10:22:02 +02:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNNodeMetric2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetric(ctx, sel, v[i])
2021-10-26 10:22:02 +02:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNNodeMetric2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetric(ctx context.Context, sel ast.SelectionSet, v *model.NodeMetric) graphql.Marshaler {
2021-10-26 10:22:02 +02:00
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
return ec._NodeMetric(ctx, sel, v)
2021-04-22 15:00:54 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNNodeMetrics2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetricsᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.NodeMetrics) graphql.Marshaler {
2021-04-22 15:00:54 +02:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNNodeMetrics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetrics(ctx, sel, v[i])
2021-04-22 15:00:54 +02:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNNodeMetrics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐNodeMetrics(ctx context.Context, sel ast.SelectionSet, v *model.NodeMetrics) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._NodeMetrics(ctx, sel, v)
}
func (ec *executionContext) unmarshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloat(ctx context.Context, v interface{}) (schema.Float, error) {
var res schema.Float
err := res.UnmarshalGQL(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloat(ctx context.Context, sel ast.SelectionSet, v schema.Float) graphql.Marshaler {
return v
}
func (ec *executionContext) unmarshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx context.Context, v interface{}) ([]schema.Float, error) {
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]schema.Float, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloat(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalNNullableFloat2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloatᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.Float) graphql.Marshaler {
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNNullableFloat2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐFloat(ctx, sel, v[i])
}
return ret
}
func (ec *executionContext) marshalNPartition2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐPartitionᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.Partition) graphql.Marshaler {
2021-12-09 16:25:48 +01:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNPartition2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐPartition(ctx, sel, v[i])
2021-12-09 16:25:48 +01:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNPartition2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐPartition(ctx context.Context, sel ast.SelectionSet, v *model.Partition) graphql.Marshaler {
2021-12-09 16:25:48 +01:00
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
2021-12-17 15:49:22 +01:00
return ec._Partition(ctx, sel, v)
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) marshalNResource2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐResourceᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Resource) graphql.Marshaler {
2021-12-09 16:25:48 +01:00
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2022-01-07 09:44:34 +01:00
ret[i] = ec.marshalNResource2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐResource(ctx, sel, v[i])
2021-12-09 16:25:48 +01:00
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) marshalNResource2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐResource(ctx context.Context, sel ast.SelectionSet, v *schema.Resource) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._Resource(ctx, sel, v)
}
func (ec *executionContext) marshalNSeries2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐSeries(ctx context.Context, sel ast.SelectionSet, v schema.Series) graphql.Marshaler {
return ec._Series(ctx, sel, &v)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) unmarshalNSortDirectionEnum2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐSortDirectionEnum(ctx context.Context, v interface{}) (model.SortDirectionEnum, error) {
var res model.SortDirectionEnum
2021-10-26 10:22:02 +02:00
err := res.UnmarshalGQL(v)
return res, graphql.ErrorOnPath(ctx, err)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNSortDirectionEnum2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐSortDirectionEnum(ctx context.Context, sel ast.SelectionSet, v model.SortDirectionEnum) graphql.Marshaler {
2021-10-26 10:22:02 +02:00
return v
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {
res, err := graphql.UnmarshalString(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
res := graphql.MarshalString(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalNString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
2021-09-23 11:45:20 +02:00
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
2021-10-26 10:22:02 +02:00
res := make([]string, len(vSlice))
2021-09-23 11:45:20 +02:00
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2021-10-26 10:22:02 +02:00
res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
2021-09-23 11:45:20 +02:00
if err != nil {
return nil, err
}
}
return res, nil
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalNString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
2021-09-23 11:45:20 +02:00
ret := make(graphql.Array, len(v))
for i := range v {
2021-10-26 10:22:02 +02:00
ret[i] = ec.marshalNString2string(ctx, sel, v[i])
2021-09-23 11:45:20 +02:00
}
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNTag2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTag(ctx context.Context, sel ast.SelectionSet, v schema.Tag) graphql.Marshaler {
return ec._Tag(ctx, sel, &v)
}
func (ec *executionContext) marshalNTag2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTagᚄ(ctx context.Context, sel ast.SelectionSet, v []*schema.Tag) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalNTag2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTag(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalNTag2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐTag(ctx context.Context, sel ast.SelectionSet, v *schema.Tag) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._Tag(ctx, sel, v)
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalNTime2timeᚐTime(ctx context.Context, v interface{}) (time.Time, error) {
res, err := graphql.UnmarshalTime(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalNTime2timeᚐTime(ctx context.Context, sel ast.SelectionSet, v time.Time) graphql.Marshaler {
res := graphql.MarshalTime(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
func (ec *executionContext) marshalNTimeRangeOutput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐTimeRangeOutput(ctx context.Context, sel ast.SelectionSet, v *model.TimeRangeOutput) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._TimeRangeOutput(ctx, sel, v)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalNTopology2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐTopology(ctx context.Context, sel ast.SelectionSet, v *model.Topology) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec._Topology(ctx, sel, v)
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {
return ec.___Directive(ctx, sel, &v)
}
func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {
res, err := graphql.UnmarshalString(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
res := graphql.MarshalString(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]string, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {
return ec.___EnumValue(ctx, sel, &v)
}
func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {
return ec.___Field(ctx, sel, &v)
}
func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {
return ec.___InputValue(ctx, sel, &v)
}
func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {
return ec.___Type(ctx, sel, &v)
}
func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
if v == nil {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
return graphql.Null
}
return ec.___Type(ctx, sel, v)
}
func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {
res, err := graphql.UnmarshalString(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
res := graphql.MarshalString(v)
if res == graphql.Null {
if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
ec.Errorf(ctx, "must not be null")
}
}
return res
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalOAccelerator2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐAcceleratorᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.Accelerator) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2021-12-17 15:49:22 +01:00
ret[i] = ec.marshalNAccelerator2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐAccelerator(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalOAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐAggregate(ctx context.Context, v interface{}) (*model.Aggregate, error) {
2021-03-31 08:50:53 +02:00
if v == nil {
return nil, nil
}
2021-10-26 10:22:02 +02:00
var res = new(model.Aggregate)
err := res.UnmarshalGQL(v)
return res, graphql.ErrorOnPath(ctx, err)
2021-03-31 08:50:53 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalOAggregate2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐAggregate(ctx context.Context, sel ast.SelectionSet, v *model.Aggregate) graphql.Marshaler {
2021-03-31 08:50:53 +02:00
if v == nil {
return graphql.Null
}
2021-10-26 10:22:02 +02:00
return v
2021-03-31 08:50:53 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {
res, err := graphql.UnmarshalBoolean(v)
return res, graphql.ErrorOnPath(ctx, err)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {
return graphql.MarshalBoolean(v)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {
2021-09-23 11:45:20 +02:00
if v == nil {
return nil, nil
}
2021-10-26 10:22:02 +02:00
res, err := graphql.UnmarshalBoolean(v)
return &res, graphql.ErrorOnPath(ctx, err)
2021-09-23 11:45:20 +02:00
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {
2021-09-23 11:45:20 +02:00
if v == nil {
return graphql.Null
}
2021-10-26 10:22:02 +02:00
return graphql.MarshalBoolean(*v)
2021-09-23 11:45:20 +02:00
}
func (ec *executionContext) unmarshalOFloatRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐFloatRange(ctx context.Context, v interface{}) (*model.FloatRange, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalInputFloatRange(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) unmarshalOID2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
if v == nil {
return nil, nil
}
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]string, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNID2string(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalOID2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNID2string(ctx, sel, v[i])
}
return ret
}
func (ec *executionContext) unmarshalOInt2ᚕintᚄ(ctx context.Context, v interface{}) ([]int, error) {
if v == nil {
return nil, nil
}
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]int, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNInt2int(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalOInt2ᚕintᚄ(ctx context.Context, sel ast.SelectionSet, v []int) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNInt2int(ctx, sel, v[i])
}
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) unmarshalOInt2ᚕᚕintᚄ(ctx context.Context, v interface{}) ([][]int, error) {
if v == nil {
return nil, nil
}
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([][]int, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNInt2ᚕintᚄ(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalOInt2ᚕᚕintᚄ(ctx context.Context, sel ast.SelectionSet, v [][]int) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNInt2ᚕintᚄ(ctx, sel, v[i])
}
return ret
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {
if v == nil {
return nil, nil
}
res, err := graphql.UnmarshalInt(v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalOInt2ᚖint(ctx context.Context, sel ast.SelectionSet, v *int) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return graphql.MarshalInt(*v)
}
func (ec *executionContext) unmarshalOIntRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐIntRange(ctx context.Context, v interface{}) (*model.IntRange, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalInputIntRange(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalOJob2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJob(ctx context.Context, sel ast.SelectionSet, v *schema.Job) graphql.Marshaler {
2021-03-31 08:50:53 +02:00
if v == nil {
return graphql.Null
}
return ec._Job(ctx, sel, v)
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalOJobFilter2ᚕᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilterᚄ(ctx context.Context, v interface{}) ([]*model.JobFilter, error) {
2021-03-31 08:50:53 +02:00
if v == nil {
return nil, nil
}
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]*model.JobFilter, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2021-10-26 10:22:02 +02:00
res[i], err = ec.unmarshalNJobFilter2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐJobFilter(ctx, vSlice[i])
2021-03-31 08:50:53 +02:00
if err != nil {
return nil, err
}
}
return res, nil
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) unmarshalOJobState2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobStateᚄ(ctx context.Context, v interface{}) ([]schema.JobState, error) {
if v == nil {
return nil, nil
}
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]schema.JobState, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobState(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalOJobState2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobStateᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.JobState) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNJobState2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐJobState(ctx, sel, v[i])
}
return ret
}
func (ec *executionContext) marshalOMetricFootprints2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐMetricFootprints(ctx context.Context, sel ast.SelectionSet, v *model.MetricFootprints) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return ec._MetricFootprints(ctx, sel, v)
}
2021-12-20 10:48:58 +01:00
func (ec *executionContext) unmarshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScopeᚄ(ctx context.Context, v interface{}) ([]schema.MetricScope, error) {
if v == nil {
return nil, nil
}
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
res := make([]schema.MetricScope, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
res[i], err = ec.unmarshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScope(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
func (ec *executionContext) marshalOMetricScope2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScopeᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.MetricScope) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
for i := range v {
ret[i] = ec.marshalNMetricScope2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricScope(ctx, sel, v[i])
}
return ret
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) marshalOMetricStatistics2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐMetricStatistics(ctx context.Context, sel ast.SelectionSet, v *schema.MetricStatistics) graphql.Marshaler {
2021-04-07 09:19:21 +02:00
if v == nil {
return graphql.Null
}
2021-12-17 15:49:22 +01:00
return ec._MetricStatistics(ctx, sel, v)
2021-04-07 09:19:21 +02:00
}
2021-12-17 15:49:22 +01:00
func (ec *executionContext) unmarshalOOrderByInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐOrderByInput(ctx context.Context, v interface{}) (*model.OrderByInput, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalInputOrderByInput(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) unmarshalOPageRequest2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐPageRequest(ctx context.Context, v interface{}) (*model.PageRequest, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalInputPageRequest(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) marshalOSeries2ᚕgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐSeriesᚄ(ctx context.Context, sel ast.SelectionSet, v []schema.Series) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
2022-01-07 09:44:34 +01:00
ret[i] = ec.marshalNSeries2githubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐSeries(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
2022-01-07 09:44:34 +01:00
func (ec *executionContext) marshalOStatsSeries2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋschemaᚐStatsSeries(ctx context.Context, sel ast.SelectionSet, v *schema.StatsSeries) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return ec._StatsSeries(ctx, sel, v)
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalOString2string(ctx context.Context, v interface{}) (string, error) {
res, err := graphql.UnmarshalString(v)
return res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalOString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {
return graphql.MarshalString(v)
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) unmarshalOString2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {
if v == nil {
return nil, nil
}
var vSlice []interface{}
if v != nil {
if tmp1, ok := v.([]interface{}); ok {
vSlice = tmp1
} else {
vSlice = []interface{}{v}
}
}
var err error
2021-10-26 10:22:02 +02:00
res := make([]string, len(vSlice))
for i := range vSlice {
ctx := graphql.WithPathContext(ctx, graphql.NewPathWithIndex(i))
2021-10-26 10:22:02 +02:00
res[i], err = ec.unmarshalNString2string(ctx, vSlice[i])
if err != nil {
return nil, err
}
}
return res, nil
}
2021-10-26 10:22:02 +02:00
func (ec *executionContext) marshalOString2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
for i := range v {
2021-10-26 10:22:02 +02:00
ret[i] = ec.marshalNString2string(ctx, sel, v[i])
}
return ret
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalOString2ᚖstring(ctx context.Context, v interface{}) (*string, error) {
if v == nil {
return nil, nil
}
res, err := graphql.UnmarshalString(v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalOString2ᚖstring(ctx context.Context, sel ast.SelectionSet, v *string) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return graphql.MarshalString(*v)
}
func (ec *executionContext) unmarshalOStringInput2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐStringInput(ctx context.Context, v interface{}) (*model.StringInput, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalInputStringInput(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) unmarshalOTime2ᚖtimeᚐTime(ctx context.Context, v interface{}) (*time.Time, error) {
if v == nil {
return nil, nil
}
res, err := graphql.UnmarshalTime(v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalOTime2ᚖtimeᚐTime(ctx context.Context, sel ast.SelectionSet, v *time.Time) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return graphql.MarshalTime(*v)
}
2021-03-31 08:50:53 +02:00
func (ec *executionContext) unmarshalOTimeRange2ᚖgithubᚗcomᚋClusterCockpitᚋccᚑjobarchiveᚋgraphᚋmodelᚐTimeRange(ctx context.Context, v interface{}) (*model.TimeRange, error) {
if v == nil {
return nil, nil
}
res, err := ec.unmarshalInputTimeRange(ctx, v)
return &res, graphql.ErrorOnPath(ctx, err)
}
func (ec *executionContext) marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.EnumValue) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Field) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx context.Context, sel ast.SelectionSet, v *introspection.Schema) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return ec.___Schema(ctx, sel, v)
}
func (ec *executionContext) marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {
if v == nil {
return graphql.Null
}
ret := make(graphql.Array, len(v))
var wg sync.WaitGroup
isLen1 := len(v) == 1
if !isLen1 {
wg.Add(len(v))
}
for i := range v {
i := i
fc := &graphql.FieldContext{
Index: &i,
Result: &v[i],
}
ctx := graphql.WithFieldContext(ctx, fc)
f := func(i int) {
defer func() {
if r := recover(); r != nil {
ec.Error(ctx, ec.Recover(ctx, r))
ret = nil
}
}()
if !isLen1 {
defer wg.Done()
}
ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])
}
if isLen1 {
f(i)
} else {
go f(i)
}
}
wg.Wait()
return ret
}
func (ec *executionContext) marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {
if v == nil {
return graphql.Null
}
return ec.___Type(ctx, sel, v)
}
// endregion ***************************** type.gotpl *****************************