8354446339

Committed 20 Mar 2024 05:53AM UTC coverage: 88.483% (-1.0%) from 89.48%

Build # 8354446339

Build Type

Pull #395

github

Committed by

web-flow

Commit Message

Bump postcss from 8.4.35 to 8.4.37 in /dashboard

Bumps [postcss](https://github.com/postcss/postcss) from 8.4.35 to 8.4.37.
- [Release notes](https://github.com/postcss/postcss/releases)
- [Changelog](https://github.com/postcss/postcss/blob/main/CHANGELOG.md)
- [Commits](https://github.com/postcss/postcss/compare/8.4.35...8.4.37)

---
updated-dependencies:
- dependency-name: postcss
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #395: Bump postcss from 8.4.35 to 8.4.37 in /dashboard

Run Details

799 of 903 relevant lines covered (88.48%)

12.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.18

/internal/controller/exerciseset_controller.go

/*
Copyright 2021 Maximilian Geberl.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package controller

import (
        "context"
        "fmt"
        "reflect"
        "time"

        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime"
        "k8s.io/apimachinery/pkg/types"
        ctrl "sigs.k8s.io/controller-runtime"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/log"

        kubeteachv1alpha1 "github.com/dergeberl/kubeteach/api/v1alpha1"
)

// ExerciseSetReconciler reconciles a ExerciseSet object
type ExerciseSetReconciler struct {
        client.Client
        Scheme      *runtime.Scheme
        RequeueTime time.Duration
}

//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=taskdefinitions,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=exercisesets,verbs=get;list;watch;create;update;patch;delete
//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=exercisesets/status,verbs=get;update;patch
//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=exercisesets/finalizers,verbs=update

// Reconcile handles reconcile of an ExersiceSet
func (r *ExerciseSetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
        _ = log.FromContext(ctx)

        var exerciseSet kubeteachv1alpha1.ExerciseSet
        err := r.Client.Get(ctx, req.NamespacedName, &exerciseSet)
        if err != nil {
                // ignore ExerciseSet that dose not exists
                return ctrl.Result{}, client.IgnoreNotFound(err)
        }

        var newExerciseSetStatus kubeteachv1alpha1.ExerciseSetStatus

        for _, taskDefinition := range exerciseSet.Spec.TaskDefinitions {
                var taskDefinitionObject kubeteachv1alpha1.TaskDefinition
                err = r.Client.Get(ctx, client.ObjectKey{Name: taskDefinition.Name, Namespace: req.Namespace}, &taskDefinitionObject)
                if err != nil {
                        if client.IgnoreNotFound(err) != nil {
                                return ctrl.Result{}, err
                        }
                        // create taskDefinition
                        taskDefinitionObject = kubeteachv1alpha1.TaskDefinition{
                                ObjectMeta: metav1.ObjectMeta{
                                        Name:      taskDefinition.Name,
                                        Namespace: req.Namespace,
                                        OwnerReferences: []metav1.OwnerReference{{
                                                APIVersion: exerciseSet.APIVersion,
                                                Kind:       exerciseSet.Kind,
                                                Name:       exerciseSet.Name,
                                                UID:        exerciseSet.UID,
                                        }},
                                },
                                Spec: taskDefinition.TaskDefinitionSpec,
                        }
                        err = r.Client.Create(ctx, &taskDefinitionObject)
                        if err != nil {
                                return ctrl.Result{}, err
                        }
                }

                // update TaskDefinition if needed
                if !reflect.DeepEqual(taskDefinitionObject.Spec, taskDefinition.TaskDefinitionSpec) {
                        taskDefinitionObject.Spec = taskDefinition.TaskDefinitionSpec
                        err = r.Client.Update(ctx, &taskDefinitionObject)
                        if err != nil {
                                return ctrl.Result{}, err
                        }
                }

                // update OwnerReferences if needed
                if !reflect.DeepEqual(taskDefinitionObject.OwnerReferences, []metav1.OwnerReference{{
                        APIVersion: exerciseSet.APIVersion,
                        Kind:       exerciseSet.Kind,
                        Name:       exerciseSet.Name,
                        UID:        exerciseSet.UID,
                }}) {
                        taskDefinitionObject.OwnerReferences = []metav1.OwnerReference{{
                                APIVersion: exerciseSet.APIVersion,
                                Kind:       exerciseSet.Kind,
                                Name:       exerciseSet.Name,
                                UID:        exerciseSet.UID,
                        }}
                        err = r.Client.Update(ctx, &taskDefinitionObject)
                        if err != nil {
                                return ctrl.Result{}, err
                        }
                }

                // count total tasks
                newExerciseSetStatus.NumberOfTasks++

                // count tasks with state
                if taskDefinitionObject.Status.State != nil {
                        switch *taskDefinitionObject.Status.State {
                        case StateActive:
                                newExerciseSetStatus.NumberOfActiveTasks++
                        case StatePending:
                                newExerciseSetStatus.NumberOfPendingTasks++
                        case StateSuccessful:
                                newExerciseSetStatus.NumberOfSuccessfulTasks++
                        }
                } else {
                        newExerciseSetStatus.NumberOfUnknownTasks++
                }

                // count total sum of points
                newExerciseSetStatus.PointsTotal += taskDefinition.TaskDefinitionSpec.Points

                // count tasks without points
                if taskDefinition.TaskDefinitionSpec.Points == 0 {
                        newExerciseSetStatus.NumberOfTasksWithoutPoints++
                }

                // count points from successful tasks
                if taskDefinitionObject.Status.State != nil &&
                        *taskDefinitionObject.Status.State == StateSuccessful {
                        newExerciseSetStatus.PointsAchieved += taskDefinition.TaskDefinitionSpec.Points
                }
        }

        // update status if needed
        if !reflect.DeepEqual(exerciseSet.Status, newExerciseSetStatus) {
                patch := []byte(`{"status": {` +
                        `"numberOfTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfTasks) + `, ` +
                        `"numberOfActiveTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfActiveTasks) + `, ` +
                        `"numberOfPendingTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfPendingTasks) + `, ` +
                        `"numberOfSuccessfulTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfSuccessfulTasks) + `, ` +
                        `"numberOfUnknownTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfUnknownTasks) + `, ` +
                        `"numberOfTasksWithoutPoints": ` + fmt.Sprint(newExerciseSetStatus.NumberOfTasksWithoutPoints) + `, ` +
                        `"pointsTotal": ` + fmt.Sprint(newExerciseSetStatus.PointsTotal) + `, ` +
                        `"pointsAchieved": ` + fmt.Sprint(newExerciseSetStatus.PointsAchieved) + `}}`)
                err = r.Client.Status().Patch(ctx, &exerciseSet, client.RawPatch(types.MergePatchType, patch))
                if err != nil {
                        return ctrl.Result{}, err
                }
        }

        return ctrl.Result{RequeueAfter: r.RequeueTime}, nil
}

// SetupWithManager sets up the controller with the Manager.
func (r *ExerciseSetReconciler) SetupWithManager(mgr ctrl.Manager) error {
        return ctrl.NewControllerManagedBy(mgr).
                For(&kubeteachv1alpha1.ExerciseSet{}).
                Complete(r)
}

1	/*
2	Copyright 2021 Maximilian Geberl.
3
4	Licensed under the Apache License, Version 2.0 (the "License");
5	you may not use this file except in compliance with the License.
6	You may obtain a copy of the License at
7
8	http://www.apache.org/licenses/LICENSE-2.0
9
10	Unless required by applicable law or agreed to in writing, software
11	distributed under the License is distributed on an "AS IS" BASIS,
12	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	See the License for the specific language governing permissions and
14	limitations under the License.
15	*/
16
17	package controller
18
19	import (
20	"context"
21	"fmt"
22	"reflect"
23	"time"
24
25	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
26	"k8s.io/apimachinery/pkg/runtime"
27	"k8s.io/apimachinery/pkg/types"
28	ctrl "sigs.k8s.io/controller-runtime"
29	"sigs.k8s.io/controller-runtime/pkg/client"
30	"sigs.k8s.io/controller-runtime/pkg/log"
31
32	kubeteachv1alpha1 "github.com/dergeberl/kubeteach/api/v1alpha1"
33	)
34
35	// ExerciseSetReconciler reconciles a ExerciseSet object
36	type ExerciseSetReconciler struct {
37	client.Client
38	Scheme *runtime.Scheme
39	RequeueTime time.Duration
40	}
41
42	//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=taskdefinitions,verbs=get;list;watch;create;update;patch;delete
43	//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=exercisesets,verbs=get;list;watch;create;update;patch;delete
44	//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=exercisesets/status,verbs=get;update;patch
45	//+kubebuilder:rbac:groups=kubeteach.geberl.io,resources=exercisesets/finalizers,verbs=update
46
47	// Reconcile handles reconcile of an ExersiceSet
48	func (r *ExerciseSetReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {	26✔
49	_ = log.FromContext(ctx)	26✔
50		26✔
51	var exerciseSet kubeteachv1alpha1.ExerciseSet	26✔
52	err := r.Client.Get(ctx, req.NamespacedName, &exerciseSet)	26✔
53	if err != nil {	28✔
54	// ignore ExerciseSet that dose not exists	2✔
55	return ctrl.Result{}, client.IgnoreNotFound(err)	2✔
56	}	2✔
57
58	var newExerciseSetStatus kubeteachv1alpha1.ExerciseSetStatus	24✔
59		24✔
60	for _, taskDefinition := range exerciseSet.Spec.TaskDefinitions {	168✔
61	var taskDefinitionObject kubeteachv1alpha1.TaskDefinition	144✔
62	err = r.Client.Get(ctx, client.ObjectKey{Name: taskDefinition.Name, Namespace: req.Namespace}, &taskDefinitionObject)	144✔
63	if err != nil {	150✔
64	if client.IgnoreNotFound(err) != nil {	6✔
65	return ctrl.Result{}, err	×
66	}	×
67	// create taskDefinition
68	taskDefinitionObject = kubeteachv1alpha1.TaskDefinition{	6✔
69	ObjectMeta: metav1.ObjectMeta{	6✔
70	Name: taskDefinition.Name,	6✔
71	Namespace: req.Namespace,	6✔
72	OwnerReferences: []metav1.OwnerReference{{	6✔
73	APIVersion: exerciseSet.APIVersion,	6✔
74	Kind: exerciseSet.Kind,	6✔
75	Name: exerciseSet.Name,	6✔
76	UID: exerciseSet.UID,	6✔
77	}},	6✔
78	},	6✔
79	Spec: taskDefinition.TaskDefinitionSpec,	6✔
80	}	6✔
81	err = r.Client.Create(ctx, &taskDefinitionObject)	6✔
82	if err != nil {	6✔
83	return ctrl.Result{}, err	×
84	}	×
85	}
86
87	// update TaskDefinition if needed
88	if !reflect.DeepEqual(taskDefinitionObject.Spec, taskDefinition.TaskDefinitionSpec) {	145✔
89	taskDefinitionObject.Spec = taskDefinition.TaskDefinitionSpec	1✔
90	err = r.Client.Update(ctx, &taskDefinitionObject)	1✔
91	if err != nil {	1✔
92	return ctrl.Result{}, err	×
93	}	×
94	}
95
96	// update OwnerReferences if needed
97	if !reflect.DeepEqual(taskDefinitionObject.OwnerReferences, []metav1.OwnerReference{{	144✔
98	APIVersion: exerciseSet.APIVersion,	144✔
99	Kind: exerciseSet.Kind,	144✔
100	Name: exerciseSet.Name,	144✔
101	UID: exerciseSet.UID,	144✔
102	}}) {	144✔
103	taskDefinitionObject.OwnerReferences = []metav1.OwnerReference{{	×
104	APIVersion: exerciseSet.APIVersion,	×
105	Kind: exerciseSet.Kind,	×
106	Name: exerciseSet.Name,	×
107	UID: exerciseSet.UID,	×
108	}}	×
109	err = r.Client.Update(ctx, &taskDefinitionObject)	×
110	if err != nil {	×
111	return ctrl.Result{}, err	×
112	}	×
113	}
114
115	// count total tasks
116	newExerciseSetStatus.NumberOfTasks++	144✔
117		144✔
118	// count tasks with state	144✔
119	if taskDefinitionObject.Status.State != nil {	266✔
120	switch *taskDefinitionObject.Status.State {	122✔
121	case StateActive:	44✔
122	newExerciseSetStatus.NumberOfActiveTasks++	44✔
123	case StatePending:	66✔
124	newExerciseSetStatus.NumberOfPendingTasks++	66✔
125	case StateSuccessful:	12✔
126	newExerciseSetStatus.NumberOfSuccessfulTasks++	12✔
127	}
128	} else {	22✔
129	newExerciseSetStatus.NumberOfUnknownTasks++	22✔
130	}	22✔
131
132	// count total sum of points
133	newExerciseSetStatus.PointsTotal += taskDefinition.TaskDefinitionSpec.Points	144✔
134		144✔
135	// count tasks without points	144✔
136	if taskDefinition.TaskDefinitionSpec.Points == 0 {	192✔
137	newExerciseSetStatus.NumberOfTasksWithoutPoints++	48✔
138	}	48✔
139
140	// count points from successful tasks
141	if taskDefinitionObject.Status.State != nil &&	144✔
142	*taskDefinitionObject.Status.State == StateSuccessful {	156✔
143	newExerciseSetStatus.PointsAchieved += taskDefinition.TaskDefinitionSpec.Points	12✔
144	}	12✔
145	}
146
147	// update status if needed
148	if !reflect.DeepEqual(exerciseSet.Status, newExerciseSetStatus) {	39✔
149	patch := []byte(`{"status": {` +	15✔
150	`"numberOfTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfTasks) + `, ` +	15✔
151	`"numberOfActiveTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfActiveTasks) + `, ` +	15✔
152	`"numberOfPendingTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfPendingTasks) + `, ` +	15✔
153	`"numberOfSuccessfulTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfSuccessfulTasks) + `, ` +	15✔
154	`"numberOfUnknownTasks": ` + fmt.Sprint(newExerciseSetStatus.NumberOfUnknownTasks) + `, ` +	15✔
155	`"numberOfTasksWithoutPoints": ` + fmt.Sprint(newExerciseSetStatus.NumberOfTasksWithoutPoints) + `, ` +	15✔
156	`"pointsTotal": ` + fmt.Sprint(newExerciseSetStatus.PointsTotal) + `, ` +	15✔
157	`"pointsAchieved": ` + fmt.Sprint(newExerciseSetStatus.PointsAchieved) + `}}`)	15✔
158	err = r.Client.Status().Patch(ctx, &exerciseSet, client.RawPatch(types.MergePatchType, patch))	15✔
159	if err != nil {	15✔
160	return ctrl.Result{}, err	×
161	}	×
162	}
163
164	return ctrl.Result{RequeueAfter: r.RequeueTime}, nil	24✔
165	}
166
167	// SetupWithManager sets up the controller with the Manager.
168	func (r *ExerciseSetReconciler) SetupWithManager(mgr ctrl.Manager) error {	1✔
169	return ctrl.NewControllerManagedBy(mgr).	1✔
170	For(&kubeteachv1alpha1.ExerciseSet{}).	1✔
171	Complete(r)	1✔
172	}	1✔

dergeberl / kubeteach / 8354446339

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous