cc-backend/internal/graph/schema.resolvers.go

385 lines
12 KiB
Go
Raw Normal View History

package graph
// This file will be automatically regenerated based on the schema, any resolver implementations
// will be copied through when generating and any unknown code will be moved to the end.
2023-12-01 13:22:01 +01:00
// Code generated by github.com/99designs/gqlgen version v0.17.40
import (
"context"
2021-12-09 16:25:48 +01:00
"errors"
"fmt"
"strconv"
2021-12-09 16:25:48 +01:00
"time"
2022-06-21 17:52:36 +02:00
"github.com/ClusterCockpit/cc-backend/internal/graph/generated"
"github.com/ClusterCockpit/cc-backend/internal/graph/model"
"github.com/ClusterCockpit/cc-backend/internal/metricdata"
"github.com/ClusterCockpit/cc-backend/internal/repository"
"github.com/ClusterCockpit/cc-backend/pkg/archive"
"github.com/ClusterCockpit/cc-backend/pkg/log"
2022-06-21 17:52:36 +02:00
"github.com/ClusterCockpit/cc-backend/pkg/schema"
)
// Partitions is the resolver for the partitions field.
func (r *clusterResolver) Partitions(ctx context.Context, obj *schema.Cluster) ([]string, error) {
2022-03-14 10:24:27 +01:00
return r.Repo.Partitions(obj.Name)
}
// Tags is the resolver for the tags field.
2022-03-15 11:04:54 +01:00
func (r *jobResolver) Tags(ctx context.Context, obj *schema.Job) ([]*schema.Tag, error) {
return r.Repo.GetTags(&obj.ID)
}
// ConcurrentJobs is the resolver for the concurrentJobs field.
func (r *jobResolver) ConcurrentJobs(ctx context.Context, obj *schema.Job) (*model.JobLinkResultList, error) {
2023-06-20 10:38:53 +02:00
if obj.State == schema.JobStateRunning {
obj.Duration = int32(time.Now().Unix() - obj.StartTimeUnix)
}
2023-06-20 10:38:53 +02:00
if obj.Exclusive != 1 && obj.Duration > 600 {
2023-06-22 06:26:19 +02:00
return r.Repo.FindConcurrentJobs(ctx, obj)
}
return nil, nil
}
// MetaData is the resolver for the metaData field.
func (r *jobResolver) MetaData(ctx context.Context, obj *schema.Job) (interface{}, error) {
return r.Repo.FetchMetadata(obj)
}
// UserData is the resolver for the userData field.
2022-03-15 11:04:54 +01:00
func (r *jobResolver) UserData(ctx context.Context, obj *schema.Job) (*model.User, error) {
return repository.GetUserRepository().FetchUserInCtx(ctx, obj.User)
}
// CreateTag is the resolver for the createTag field.
2021-12-17 15:49:22 +01:00
func (r *mutationResolver) CreateTag(ctx context.Context, typeArg string, name string) (*schema.Tag, error) {
2022-02-17 09:04:57 +01:00
id, err := r.Repo.CreateTag(typeArg, name)
if err != nil {
log.Warn("Error while creating tag")
return nil, err
}
2021-12-17 15:49:22 +01:00
return &schema.Tag{ID: id, Type: typeArg, Name: name}, nil
}
// DeleteTag is the resolver for the deleteTag field.
func (r *mutationResolver) DeleteTag(ctx context.Context, id string) (string, error) {
panic(fmt.Errorf("not implemented: DeleteTag - deleteTag"))
}
// AddTagsToJob is the resolver for the addTagsToJob field.
2021-12-17 15:49:22 +01:00
func (r *mutationResolver) AddTagsToJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error) {
2022-02-17 09:04:57 +01:00
jid, err := strconv.ParseInt(job, 10, 64)
if err != nil {
log.Warn("Error while adding tag to job")
return nil, err
}
2022-02-23 14:18:55 +01:00
tags := []*schema.Tag{}
for _, tagId := range tagIds {
2022-02-17 09:04:57 +01:00
tid, err := strconv.ParseInt(tagId, 10, 64)
if err != nil {
log.Warn("Error while parsing tag id")
return nil, err
}
2022-02-23 14:18:55 +01:00
if tags, err = r.Repo.AddTag(jid, tid); err != nil {
log.Warn("Error while adding tag")
return nil, err
}
}
2022-02-23 14:18:55 +01:00
return tags, nil
}
// RemoveTagsFromJob is the resolver for the removeTagsFromJob field.
2021-12-17 15:49:22 +01:00
func (r *mutationResolver) RemoveTagsFromJob(ctx context.Context, job string, tagIds []string) ([]*schema.Tag, error) {
jid, err := strconv.ParseInt(job, 10, 64)
if err != nil {
log.Warn("Error while parsing job id")
return nil, err
}
2022-02-23 14:18:55 +01:00
tags := []*schema.Tag{}
for _, tagId := range tagIds {
tid, err := strconv.ParseInt(tagId, 10, 64)
if err != nil {
log.Warn("Error while parsing tag id")
return nil, err
}
2022-02-23 14:18:55 +01:00
if tags, err = r.Repo.RemoveTag(jid, tid); err != nil {
log.Warn("Error while removing tag")
return nil, err
}
}
2022-02-23 14:18:55 +01:00
return tags, nil
}
// UpdateConfiguration is the resolver for the updateConfiguration field.
func (r *mutationResolver) UpdateConfiguration(ctx context.Context, name string, value string) (*string, error) {
if err := repository.GetUserCfgRepo().UpdateConfig(name, value, repository.GetUserFromContext(ctx)); err != nil {
log.Warn("Error while updating user config")
return nil, err
}
return nil, nil
}
// Clusters is the resolver for the clusters field.
func (r *queryResolver) Clusters(ctx context.Context) ([]*schema.Cluster, error) {
return archive.Clusters, nil
}
// Tags is the resolver for the tags field.
2021-12-17 15:49:22 +01:00
func (r *queryResolver) Tags(ctx context.Context) ([]*schema.Tag, error) {
return r.Repo.GetTags(nil)
}
// User is the resolver for the user field.
2022-03-15 11:04:54 +01:00
func (r *queryResolver) User(ctx context.Context, username string) (*model.User, error) {
return repository.GetUserRepository().FetchUserInCtx(ctx, username)
2022-03-15 11:04:54 +01:00
}
// AllocatedNodes is the resolver for the allocatedNodes field.
2022-03-24 16:08:47 +01:00
func (r *queryResolver) AllocatedNodes(ctx context.Context, cluster string) ([]*model.Count, error) {
data, err := r.Repo.AllocatedNodes(cluster)
if err != nil {
log.Warn("Error while fetching allocated nodes")
2022-03-24 16:08:47 +01:00
return nil, err
}
counts := make([]*model.Count, 0, len(data))
for subcluster, hosts := range data {
counts = append(counts, &model.Count{
Name: subcluster,
Count: len(hosts),
})
}
return counts, nil
2022-03-24 10:32:08 +01:00
}
// Job is the resolver for the job field.
2021-12-17 15:49:22 +01:00
func (r *queryResolver) Job(ctx context.Context, id string) (*schema.Job, error) {
2022-02-17 09:04:57 +01:00
numericId, err := strconv.ParseInt(id, 10, 64)
if err != nil {
log.Warn("Error while parsing job id")
2022-02-17 09:04:57 +01:00
return nil, err
}
job, err := r.Repo.FindById(numericId)
if err != nil {
log.Warn("Error while finding job by id")
2022-02-17 09:04:57 +01:00
return nil, err
}
if user := repository.GetUserFromContext(ctx); user != nil &&
job.User != user.Username &&
user.HasNotRoles([]schema.Role{schema.RoleAdmin, schema.RoleSupport, schema.RoleManager}) {
2022-02-17 09:04:57 +01:00
return nil, errors.New("you are not allowed to see this job")
2021-12-17 15:49:22 +01:00
}
2022-02-17 09:04:57 +01:00
return job, nil
}
// JobMetrics is the resolver for the jobMetrics field.
2021-12-20 10:48:58 +01:00
func (r *queryResolver) JobMetrics(ctx context.Context, id string, metrics []string, scopes []schema.MetricScope) ([]*model.JobMetricWithName, error) {
job, err := r.Query().Job(ctx, id)
if err != nil {
log.Warn("Error while querying job for metrics")
return nil, err
}
2022-01-07 09:44:34 +01:00
data, err := metricdata.LoadData(job, metrics, scopes, ctx)
if err != nil {
log.Warn("Error while loading job data")
return nil, err
}
res := []*model.JobMetricWithName{}
for name, md := range data {
2023-03-24 14:43:37 +01:00
for scope, metric := range md {
2021-12-20 10:48:58 +01:00
res = append(res, &model.JobMetricWithName{
Name: name,
2023-03-24 14:43:37 +01:00
Scope: scope,
2021-12-20 10:48:58 +01:00
Metric: metric,
})
}
}
return res, err
}
// JobsFootprints is the resolver for the jobsFootprints field.
2023-06-09 09:09:41 +02:00
func (r *queryResolver) JobsFootprints(ctx context.Context, filter []*model.JobFilter, metrics []string) (*model.Footprints, error) {
return r.jobsFootprints(ctx, filter, metrics)
}
// Jobs is the resolver for the jobs field.
2023-06-09 09:09:41 +02:00
func (r *queryResolver) Jobs(ctx context.Context, filter []*model.JobFilter, page *model.PageRequest, order *model.OrderByInput) (*model.JobResultList, error) {
if page == nil {
page = &model.PageRequest{
ItemsPerPage: 50,
Page: 1,
}
}
2022-02-17 09:04:57 +01:00
jobs, err := r.Repo.QueryJobs(ctx, filter, page, order)
if err != nil {
log.Warn("Error while querying jobs")
2022-02-17 09:04:57 +01:00
return nil, err
}
count, err := r.Repo.CountJobs(ctx, filter)
if err != nil {
log.Warn("Error while counting jobs")
return nil, err
}
return &model.JobResultList{Items: jobs, Count: &count}, nil
}
// JobsStatistics is the resolver for the jobsStatistics field.
2023-12-01 13:22:01 +01:00
func (r *queryResolver) JobsStatistics(ctx context.Context, filter []*model.JobFilter, metrics []string, page *model.PageRequest, sortBy *model.SortByAggregate, groupBy *model.Aggregate) ([]*model.JobsStatistics, error) {
2023-06-07 11:58:58 +02:00
var err error
var stats []*model.JobsStatistics
if requireField(ctx, "totalJobs") || requireField(ctx, "totalWalltime") || requireField(ctx, "totalNodes") || requireField(ctx, "totalCores") ||
requireField(ctx, "totalAccs") || requireField(ctx, "totalNodeHours") || requireField(ctx, "totalCoreHours") || requireField(ctx, "totalAccHours") {
2023-06-09 09:09:41 +02:00
if groupBy == nil {
stats, err = r.Repo.JobsStats(ctx, filter)
2023-06-07 11:58:58 +02:00
} else {
stats, err = r.Repo.JobsStatsGrouped(ctx, filter, page, sortBy, groupBy)
2023-06-07 11:58:58 +02:00
}
} else {
stats = make([]*model.JobsStatistics, 0, 1)
2023-08-24 14:55:49 +02:00
stats = append(stats, &model.JobsStatistics{})
2023-06-07 11:58:58 +02:00
}
2023-06-09 09:09:41 +02:00
if groupBy != nil {
if requireField(ctx, "shortJobs") {
stats, err = r.Repo.AddJobCountGrouped(ctx, filter, groupBy, stats, "short")
}
2023-08-24 14:55:49 +02:00
if requireField(ctx, "runningJobs") {
2023-06-09 09:09:41 +02:00
stats, err = r.Repo.AddJobCountGrouped(ctx, filter, groupBy, stats, "running")
}
} else {
2023-06-09 13:15:25 +02:00
if requireField(ctx, "shortJobs") {
stats, err = r.Repo.AddJobCount(ctx, filter, stats, "short")
}
2023-08-24 14:55:49 +02:00
if requireField(ctx, "runningJobs") {
2023-06-09 13:15:25 +02:00
stats, err = r.Repo.AddJobCount(ctx, filter, stats, "running")
}
2023-06-09 09:09:41 +02:00
}
2023-06-07 11:58:58 +02:00
if err != nil {
return nil, err
}
if requireField(ctx, "histDuration") || requireField(ctx, "histNumNodes") || requireField(ctx, "histNumCores") || requireField(ctx, "histNumAccs") {
2023-06-07 11:58:58 +02:00
if groupBy == nil {
stats[0], err = r.Repo.AddHistograms(ctx, filter, stats[0])
if err != nil {
return nil, err
}
} else {
return nil, errors.New("histograms only implemented without groupBy argument")
}
}
2023-12-01 13:22:01 +01:00
if requireField(ctx, "histMetrics") {
if groupBy == nil {
stats[0], err = r.Repo.AddMetricHistograms(ctx, filter, metrics, stats[0])
if err != nil {
return nil, err
}
} else {
return nil, errors.New("metric histograms only implemented without groupBy argument")
}
}
2023-06-07 11:58:58 +02:00
return stats, nil
}
// RooflineHeatmap is the resolver for the rooflineHeatmap field.
func (r *queryResolver) RooflineHeatmap(ctx context.Context, filter []*model.JobFilter, rows int, cols int, minX float64, minY float64, maxX float64, maxY float64) ([][]float64, error) {
return r.rooflineHeatmap(ctx, filter, rows, cols, minX, minY, maxX, maxY)
}
// NodeMetrics is the resolver for the nodeMetrics field.
func (r *queryResolver) NodeMetrics(ctx context.Context, cluster string, nodes []string, scopes []schema.MetricScope, metrics []string, from time.Time, to time.Time) ([]*model.NodeMetrics, error) {
user := repository.GetUserFromContext(ctx)
if user != nil && !user.HasRole(schema.RoleAdmin) {
2021-12-09 16:25:48 +01:00
return nil, errors.New("you need to be an administrator for this query")
}
2022-02-02 13:59:08 +01:00
if metrics == nil {
for _, mc := range archive.GetCluster(cluster).MetricConfig {
2022-02-02 13:59:08 +01:00
metrics = append(metrics, mc.Name)
}
}
data, err := metricdata.LoadNodeData(cluster, metrics, nodes, scopes, from, to, ctx)
if err != nil {
log.Warn("Error while loading node data")
return nil, err
}
nodeMetrics := make([]*model.NodeMetrics, 0, len(data))
for hostname, metrics := range data {
host := &model.NodeMetrics{
Host: hostname,
Metrics: make([]*model.JobMetricWithName, 0, len(metrics)*len(scopes)),
}
host.SubCluster, _ = archive.GetSubClusterByNode(cluster, hostname)
for metric, scopedMetrics := range metrics {
for _, scopedMetric := range scopedMetrics {
host.Metrics = append(host.Metrics, &model.JobMetricWithName{
Name: metric,
Scope: schema.MetricScopeNode,
Metric: scopedMetric,
})
}
}
nodeMetrics = append(nodeMetrics, host)
}
return nodeMetrics, nil
2021-12-09 16:25:48 +01:00
}
// NumberOfNodes is the resolver for the numberOfNodes field.
func (r *subClusterResolver) NumberOfNodes(ctx context.Context, obj *schema.SubCluster) (int, error) {
nodeList, err := archive.ParseNodeList(obj.Nodes)
if err != nil {
return 0, err
}
return nodeList.NodeCount(), nil
}
// Cluster returns generated.ClusterResolver implementation.
func (r *Resolver) Cluster() generated.ClusterResolver { return &clusterResolver{r} }
// Job returns generated.JobResolver implementation.
func (r *Resolver) Job() generated.JobResolver { return &jobResolver{r} }
// Mutation returns generated.MutationResolver implementation.
func (r *Resolver) Mutation() generated.MutationResolver { return &mutationResolver{r} }
// Query returns generated.QueryResolver implementation.
func (r *Resolver) Query() generated.QueryResolver { return &queryResolver{r} }
// SubCluster returns generated.SubClusterResolver implementation.
func (r *Resolver) SubCluster() generated.SubClusterResolver { return &subClusterResolver{r} }
type clusterResolver struct{ *Resolver }
type jobResolver struct{ *Resolver }
type mutationResolver struct{ *Resolver }
type queryResolver struct{ *Resolver }
type subClusterResolver struct{ *Resolver }