21902989333

Committed 11 Feb 2026 11:18AM UTC coverage: 83.946% (+0.1%) from 83.835%

Build # 21902989333

Build Type

push

github

Committed by

web-flow

Commit Message

fix(deps): update kubernetes packages to v0.35.1 (#205)

This PR contains the following updates:

| Package | Change |
[Age](https://docs.renovatebot.com/merge-confidence/) |
[Confidence](https://docs.renovatebot.com/merge-confidence/) |
|---|---|---|---|
| [k8s.io/api](https://redirect.github.com/kubernetes/api) | `v0.35.0` →
`v0.35.1` |
![age](https://developer.mend.io/api/mc/badges/age/go/k8s.io%2fapi/v0.35.1?slim=true)
|
![confidence](https://developer.mend.io/api/mc/badges/confidence/go/k8s.io%2fapi/v0.35.0/v0.35.1?slim=true)
|
|
[k8s.io/apimachinery](https://redirect.github.com/kubernetes/apimachinery)
| `v0.35.0` → `v0.35.1` |
![age](https://developer.mend.io/api/mc/badges/age/go/k8s.io%2fapimachinery/v0.35.1?slim=true)
|
![confidence](https://developer.mend.io/api/mc/badges/confidence/go/k8s.io%2fapimachinery/v0.35.0/v0.35.1?slim=true)
|
| [k8s.io/apiserver](https://redirect.github.com/kubernetes/apiserver) |
`v0.35.0` → `v0.35.1` |
![age](https://developer.mend.io/api/mc/badges/age/go/k8s.io%2fapiserver/v0.35.1?slim=true)
|
![confidence](https://developer.mend.io/api/mc/badges/confidence/go/k8s.io%2fapiserver/v0.35.0/v0.35.1?slim=true)
|
| [k8s.io/client-go](https://redirect.github.com/kubernetes/client-go) |
`v0.35.0` → `v0.35.1` |
![age](https://developer.mend.io/api/mc/badges/age/go/k8s.io%2fclient-go/v0.35.1?slim=true)
|
![confidence](https://developer.mend.io/api/mc/badges/confidence/go/k8s.io%2fclient-go/v0.35.0/v0.35.1?slim=true)
|
|
[k8s.io/code-generator](https://redirect.github.com/kubernetes/code-generator)
| `v0.35.0` → `v0.35.1` |
![age](https://developer.mend.io/api/mc/badges/age/go/k8s.io%2fcode-generator/v0.35.1?slim=true)
|
![confidence](https://developer.mend.io/api/mc/badges/confidence/go/k8s.io%2fcode-generator/v0.35.0/v0.35.1?slim=true)
|

---

### Release Notes

<details>
<summary>kubernetes/api (k8s.io/api)</summary>

###
[`v0.35.1`](https://redirect.github.com/kubernetes/api/compare/v0.35.0...v0.35.1)

[Compare
Source]... (continued)

Coverage Stats

753 of 897 relevant lines covered (83.95%)

356.4 hits per line

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

82.27

/pkg/controller/workflow_handler.go

// Copyright 2025 BWI GmbH and Artifact Conduit contributors
// SPDX-License-Identifier: Apache-2.0

package controller

import (
        "context"
        "fmt"

        wfv1alpha1 "github.com/argoproj/argo-workflows/v3/pkg/apis/workflow/v1alpha1"
        "github.com/go-logr/logr"
        "github.com/jastBytes/sprint"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "sigs.k8s.io/controller-runtime/pkg/client"
        "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"

        arcv1alpha1 "go.opendefense.cloud/arc/api/arc/v1alpha1"
)

type WorkflowHandler interface {
        DeleteArgoResources(ctx context.Context) error
        CreateArgoResources(ctx context.Context) error
        CheckArgoResources(ctx context.Context) error
}

var _ WorkflowHandler = &SingleWorkflowHandler{}

type SingleWorkflowHandler struct {
        *ArtifactWorkflowReconciler
        log logr.Logger
        aw  *arcv1alpha1.ArtifactWorkflow
}

func NewSingleWorkflowHandler(r *ArtifactWorkflowReconciler, log logr.Logger, aw *arcv1alpha1.ArtifactWorkflow) *SingleWorkflowHandler {
        return &SingleWorkflowHandler{r, log, aw}
}

func (h *SingleWorkflowHandler) DeleteArgoResources(ctx context.Context) error {
        wf := wfv1alpha1.Workflow{
                ObjectMeta: metav1.ObjectMeta{
                        Namespace: h.aw.Namespace,
                        Name:      h.aw.Name,
                },
        }
        if err := h.Delete(ctx, &wf); client.IgnoreNotFound(err) != nil {
                h.Recorder.Event(h.aw, corev1.EventTypeWarning, "DeletionFailed", fmt.Sprintf("Failed to delete associated workflow '%s': %v", h.aw.Name, err))
                return errLogAndWrap(h.log, err, "workflow deletion failed")
        }
        h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Deleted", fmt.Sprintf("Deleted workflow '%s'", h.aw.Name))

        return nil
}

func (h *SingleWorkflowHandler) CreateArgoResources(ctx context.Context) error {
        srcSecret, dstSecret, err := h.retrieveSecrets(ctx, h.aw)
        if err != nil {
                return errLogAndWrap(h.log, err, "failed to fetch secrets for artifact workflow")
        }

        wf := hydrateArgoWorkflow(h.aw, srcSecret, dstSecret)

        if err := controllerutil.SetControllerReference(h.aw, wf, h.Scheme); err != nil {
                return errLogAndWrap(h.log, err, "failed to set controller reference")
        }

        if err := h.Create(ctx, wf); client.IgnoreAlreadyExists(err) != nil {
                h.Recorder.Event(h.aw, corev1.EventTypeWarning, "CreationFailed", fmt.Sprintf("Failed to create workflow '%s': %v", wf.GetName(), err))
                return errLogAndWrap(h.log, err, "failed to create argo workflow")
        }
        h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Created", fmt.Sprintf("Created workflow '%s'", wf.GetName()))

        h.aw.Status.Phase = arcv1alpha1.WorkflowPending
        if err := h.Status().Update(ctx, h.aw); err != nil {
                return errLogAndWrap(h.log, err, "failed to update status")
        }

        return nil
}

func (h *SingleWorkflowHandler) CheckArgoResources(ctx context.Context) error {
        wf := wfv1alpha1.Workflow{}
        if err := h.Get(ctx, namespacedName(h.aw.Namespace, h.aw.Name), &wf); err != nil {
                return errLogAndWrap(h.log, err, "failed to get workflow")
        }

        if updated := h.setStatusFromWorkflow(ctx, h.log, h.aw, &wf); !updated {
                return nil // nothing updated
        }

        if err := h.Status().Update(ctx, h.aw); err != nil {
                return errLogAndWrap(h.log, err, "failed to update status")
        }

        return nil
}

var _ WorkflowHandler = &CronWorkflowHandler{}

type CronWorkflowHandler struct {
        *ArtifactWorkflowReconciler
        log logr.Logger
        aw  *arcv1alpha1.ArtifactWorkflow
}

func NewCronWorkflowHandler(r *ArtifactWorkflowReconciler, log logr.Logger, aw *arcv1alpha1.ArtifactWorkflow) *CronWorkflowHandler {
        return &CronWorkflowHandler{r, log, aw}
}

func (h *CronWorkflowHandler) DeleteArgoResources(ctx context.Context) error {
        cwf := wfv1alpha1.CronWorkflow{
                ObjectMeta: metav1.ObjectMeta{
                        Namespace: h.aw.Namespace,
                        Name:      h.aw.Name,
                },
        }
        if err := h.Delete(ctx, &cwf); client.IgnoreNotFound(err) != nil {
                h.Recorder.Event(h.aw, corev1.EventTypeWarning, "DeletionFailed", fmt.Sprintf("Failed to delete associated cron workflow '%s': %v", h.aw.Name, err))
                return errLogAndWrap(h.log, err, "cron workflow deletion failed")
        }
        h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Deleted", fmt.Sprintf("Deleted cron workflow '%s'", h.aw.Name))

        return nil
}

func (h *CronWorkflowHandler) CreateArgoResources(ctx context.Context) error {
        srcSecret, dstSecret, err := h.retrieveSecrets(ctx, h.aw)
        if err != nil {
                return errLogAndWrap(h.log, err, "failed to fetch secrets for artifact workflow")
        }

        cwf := hydrateArgoCronWorkflow(h.aw, srcSecret, dstSecret)

        if err := controllerutil.SetControllerReference(h.aw, cwf, h.Scheme); err != nil {
                return errLogAndWrap(h.log, err, "failed to set controller reference")
        }

        if err := h.Create(ctx, cwf); err != nil {
                if client.IgnoreAlreadyExists(err) != nil {
                        h.Recorder.Event(h.aw, corev1.EventTypeWarning, "CreationFailed", fmt.Sprintf("Failed to create cron workflow '%s': %v", cwf.GetName(), err))
                        return errLogAndWrap(h.log, err, "failed to create argo cron workflow")
                }
        } else {
                h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Created", fmt.Sprintf("Created cron workflow '%s'", cwf.GetName()))
        }

        h.aw.Status.Phase = arcv1alpha1.WorkflowPending
        if err := h.Status().Update(ctx, h.aw); err != nil {
                return errLogAndWrap(h.log, err, "failed to update status")
        }

        return nil
}

func (h *CronWorkflowHandler) CheckArgoResources(ctx context.Context) error {
        cwf := wfv1alpha1.CronWorkflow{}
        if err := h.Get(ctx, namespacedName(h.aw.Namespace, h.aw.Name), &cwf); err != nil {
                return errLogAndWrap(h.log, err, "failed to get cron workflow")
        }

        updated := false

        if !h.aw.Status.LastScheduled.Equal(cwf.Status.LastScheduledTime) {
                h.aw.Status.LastScheduled = cwf.Status.LastScheduledTime
                updated = true
        }
        if h.aw.Status.Failed != cwf.Status.Failed {
                h.aw.Status.Failed = cwf.Status.Failed
                updated = true
        }
        if h.aw.Status.Succeeded != cwf.Status.Succeeded {
                h.aw.Status.Succeeded = cwf.Status.Succeeded
                updated = true
        }

        // If the active workflow is not the same as the current one, update the reference
        if len(cwf.Status.Active) > 0 {
                // Should only contain a single element at most (expected to be in the same namespace!)
                ref := cwf.Status.Active[len(cwf.Status.Active)-1]

                if h.aw.Status.ActiveWorkflowRef.Name != ref.Name {
                        h.log.V(1).Info("Updating reference for cron workflow", "cronWorkflow", cwf.Name, "activeWorkflow", ref.Name)

                        // Get the active workflow
                        wf := wfv1alpha1.Workflow{}
                        if err := h.Get(ctx, namespacedName(h.aw.Namespace, ref.Name), &wf); err != nil {
                                return errLogAndWrap(h.log, err, "failed to fetch active workflow")
                        }

                        h.aw.Status.ActiveWorkflowRef = corev1.LocalObjectReference{
                                Name: wf.Name,
                        }
                        h.aw.Status.Message = ""
                        h.aw.Status.Phase = arcv1alpha1.WorkflowActive

                        updated = updated || h.setStatusFromWorkflow(ctx, h.log, h.aw, &wf)
                }
        }

        // If there is an active workflow, check its status
        if h.aw.Status.ActiveWorkflowRef.Name != "" {
                wf := wfv1alpha1.Workflow{}
                if err := h.Get(ctx, namespacedName(h.aw.Namespace, h.aw.Status.ActiveWorkflowRef.Name), &wf); err != nil {
                        return errLogAndWrap(h.log, err, "failed to fetch active workflow")
                }

                updated = updated || h.setStatusFromWorkflow(ctx, h.log, h.aw, &wf)

                if wf.Status.Phase.Completed() {
                        h.aw.Status.ActiveWorkflowRef.Name = ""
                        updated = true
                }
        }

        if !updated {
                return nil
        }

        h.log.V(1).Info("Updating status from active workflow", "cronWorkflow", cwf.Name)

        if err := h.Status().Update(ctx, h.aw); err != nil {
                return errLogAndWrap(h.log, err, "failed to update status")
        }

        return nil
}

func hydrateArgoWorkflowSpec(aw *arcv1alpha1.ArtifactWorkflow, srcSecret *corev1.Secret, dstSecret *corev1.Secret) wfv1alpha1.WorkflowSpec {
        srcVolume := corev1.Volume{
                Name: "src-secret-vol",
                VolumeSource: corev1.VolumeSource{
                        EmptyDir: &corev1.EmptyDirVolumeSource{},
                },
        }
        if srcSecret.Name != "" {
                srcVolume.VolumeSource = corev1.VolumeSource{
                        Secret: &corev1.SecretVolumeSource{
                                SecretName: srcSecret.Name,
                        },
                }
        }

        dstVolume := corev1.Volume{
                Name: "dst-secret-vol",
                VolumeSource: corev1.VolumeSource{
                        EmptyDir: &corev1.EmptyDirVolumeSource{},
                },
        }
        if dstSecret.Name != "" {
                dstVolume.VolumeSource = corev1.VolumeSource{
                        Secret: &corev1.SecretVolumeSource{
                                SecretName: dstSecret.Name,
                        },
                }
        }

        parameters := []wfv1alpha1.Parameter{}
        for _, p := range aw.Spec.Parameters {
                parameters = append(parameters, wfv1alpha1.Parameter{
                        Name:  p.Name,
                        Value: (*wfv1alpha1.AnyString)(&p.Value),
                })
        }

        return wfv1alpha1.WorkflowSpec{
                WorkflowTemplateRef: &wfv1alpha1.WorkflowTemplateRef{
                        Name:         aw.Spec.WorkflowTemplateRef.Name,
                        ClusterScope: aw.Spec.WorkflowTemplateRef.ClusterScope,
                },
                Volumes: []corev1.Volume{
                        srcVolume,
                        dstVolume,
                },
                Arguments: wfv1alpha1.Arguments{
                        Parameters: parameters,
                },
        }
}

func hydrateArgoWorkflow(aw *arcv1alpha1.ArtifactWorkflow, srcSecret *corev1.Secret, dstSecret *corev1.Secret) *wfv1alpha1.Workflow {
        return &wfv1alpha1.Workflow{
                ObjectMeta: workflowObjectMeta(aw),
                Spec:       hydrateArgoWorkflowSpec(aw, srcSecret, dstSecret),
        }
}

func hydrateArgoCronWorkflow(aw *arcv1alpha1.ArtifactWorkflow, srcSecret *corev1.Secret, dstSecret *corev1.Secret) *wfv1alpha1.CronWorkflow {
        om := workflowObjectMeta(aw)
        wf := &wfv1alpha1.CronWorkflow{
                ObjectMeta: om,
                Spec: wfv1alpha1.CronWorkflowSpec{
                        WorkflowSpec:               hydrateArgoWorkflowSpec(aw, srcSecret, dstSecret),
                        Schedules:                  aw.Spec.Cron.Schedules,
                        ConcurrencyPolicy:          wfv1alpha1.ReplaceConcurrent,
                        StartingDeadlineSeconds:    aw.Spec.Cron.StartingDeadlineSeconds,
                        Timezone:                   aw.Spec.Cron.Timezone,
                        When:                       aw.Spec.Cron.When,
                        SuccessfulJobsHistoryLimit: sprint.ToPointer(int32(1)),
                        FailedJobsHistoryLimit:     sprint.ToPointer(int32(1)),
                        WorkflowMetadata:           &om,
                },
        }

        return wf
}

1	// Copyright 2025 BWI GmbH and Artifact Conduit contributors
2	// SPDX-License-Identifier: Apache-2.0
3
4	package controller
5
6	import (
7	"context"
8	"fmt"
9
10	wfv1alpha1 "github.com/argoproj/argo-workflows/v3/pkg/apis/workflow/v1alpha1"
11	"github.com/go-logr/logr"
12	"github.com/jastBytes/sprint"
13	corev1 "k8s.io/api/core/v1"
14	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
15	"sigs.k8s.io/controller-runtime/pkg/client"
16	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
17
18	arcv1alpha1 "go.opendefense.cloud/arc/api/arc/v1alpha1"
19	)
20
21	type WorkflowHandler interface {
22	DeleteArgoResources(ctx context.Context) error
23	CreateArgoResources(ctx context.Context) error
24	CheckArgoResources(ctx context.Context) error
25	}
26
27	var _ WorkflowHandler = &SingleWorkflowHandler{}
28
29	type SingleWorkflowHandler struct {
30	*ArtifactWorkflowReconciler
31	log logr.Logger
32	aw *arcv1alpha1.ArtifactWorkflow
33	}
34
35	func NewSingleWorkflowHandler(r ArtifactWorkflowReconciler, log logr.Logger, aw arcv1alpha1.ArtifactWorkflow) *SingleWorkflowHandler {	1,277✔
36	return &SingleWorkflowHandler{r, log, aw}	1,277✔
37	}	1,277✔
38
39	func (h *SingleWorkflowHandler) DeleteArgoResources(ctx context.Context) error {	6✔
40	wf := wfv1alpha1.Workflow{	6✔
41	ObjectMeta: metav1.ObjectMeta{	6✔
42	Namespace: h.aw.Namespace,	6✔
43	Name: h.aw.Name,	6✔
44	},	6✔
45	}	6✔
46	if err := h.Delete(ctx, &wf); client.IgnoreNotFound(err) != nil {	6✔
47	h.Recorder.Event(h.aw, corev1.EventTypeWarning, "DeletionFailed", fmt.Sprintf("Failed to delete associated workflow '%s': %v", h.aw.Name, err))	×
48	return errLogAndWrap(h.log, err, "workflow deletion failed")	×
49	}	×
50	h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Deleted", fmt.Sprintf("Deleted workflow '%s'", h.aw.Name))	6✔
51		6✔
52	return nil	6✔
53	}
54
55	func (h *SingleWorkflowHandler) CreateArgoResources(ctx context.Context) error {	726✔
56	srcSecret, dstSecret, err := h.retrieveSecrets(ctx, h.aw)	726✔
57	if err != nil {	726✔
58	return errLogAndWrap(h.log, err, "failed to fetch secrets for artifact workflow")	×
59	}	×
60
61	wf := hydrateArgoWorkflow(h.aw, srcSecret, dstSecret)	726✔
62		726✔
63	if err := controllerutil.SetControllerReference(h.aw, wf, h.Scheme); err != nil {	726✔
64	return errLogAndWrap(h.log, err, "failed to set controller reference")	×
65	}	×
66
67	if err := h.Create(ctx, wf); client.IgnoreAlreadyExists(err) != nil {	935✔
68	h.Recorder.Event(h.aw, corev1.EventTypeWarning, "CreationFailed", fmt.Sprintf("Failed to create workflow '%s': %v", wf.GetName(), err))	209✔
69	return errLogAndWrap(h.log, err, "failed to create argo workflow")	209✔
70	}	209✔
71	h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Created", fmt.Sprintf("Created workflow '%s'", wf.GetName()))	517✔
72		517✔
73	h.aw.Status.Phase = arcv1alpha1.WorkflowPending	517✔
74	if err := h.Status().Update(ctx, h.aw); err != nil {	523✔
75	return errLogAndWrap(h.log, err, "failed to update status")	6✔
76	}	6✔
77
78	return nil	511✔
79	}
80
81	func (h *SingleWorkflowHandler) CheckArgoResources(ctx context.Context) error {	514✔
82	wf := wfv1alpha1.Workflow{}	514✔
83	if err := h.Get(ctx, namespacedName(h.aw.Namespace, h.aw.Name), &wf); err != nil {	514✔
84	return errLogAndWrap(h.log, err, "failed to get workflow")	×
85	}	×
86
87	if updated := h.setStatusFromWorkflow(ctx, h.log, h.aw, &wf); !updated {	518✔
88	return nil // nothing updated	4✔
89	}	4✔
90
91	if err := h.Status().Update(ctx, h.aw); err != nil {	510✔
92	return errLogAndWrap(h.log, err, "failed to update status")	×
93	}	×
94
95	return nil	510✔
96	}
97
98	var _ WorkflowHandler = &CronWorkflowHandler{}
99
100	type CronWorkflowHandler struct {
101	*ArtifactWorkflowReconciler
102	log logr.Logger
103	aw *arcv1alpha1.ArtifactWorkflow
104	}
105
106	func NewCronWorkflowHandler(r ArtifactWorkflowReconciler, log logr.Logger, aw arcv1alpha1.ArtifactWorkflow) *CronWorkflowHandler {	28✔
107	return &CronWorkflowHandler{r, log, aw}	28✔
108	}	28✔
109
110	func (h *CronWorkflowHandler) DeleteArgoResources(ctx context.Context) error {	×
111	cwf := wfv1alpha1.CronWorkflow{	×
112	ObjectMeta: metav1.ObjectMeta{	×
113	Namespace: h.aw.Namespace,	×
114	Name: h.aw.Name,	×
115	},	×
116	}	×
117	if err := h.Delete(ctx, &cwf); client.IgnoreNotFound(err) != nil {	×
118	h.Recorder.Event(h.aw, corev1.EventTypeWarning, "DeletionFailed", fmt.Sprintf("Failed to delete associated cron workflow '%s': %v", h.aw.Name, err))	×
119	return errLogAndWrap(h.log, err, "cron workflow deletion failed")	×
120	}	×
121	h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Deleted", fmt.Sprintf("Deleted cron workflow '%s'", h.aw.Name))	×
122		×
123	return nil	×
124	}
125
126	func (h *CronWorkflowHandler) CreateArgoResources(ctx context.Context) error {	12✔
127	srcSecret, dstSecret, err := h.retrieveSecrets(ctx, h.aw)	12✔
128	if err != nil {	12✔
129	return errLogAndWrap(h.log, err, "failed to fetch secrets for artifact workflow")	×
130	}	×
131
132	cwf := hydrateArgoCronWorkflow(h.aw, srcSecret, dstSecret)	12✔
133		12✔
134	if err := controllerutil.SetControllerReference(h.aw, cwf, h.Scheme); err != nil {	12✔
135	return errLogAndWrap(h.log, err, "failed to set controller reference")	×
136	}	×
137
138	if err := h.Create(ctx, cwf); err != nil {	23✔
139	if client.IgnoreAlreadyExists(err) != nil {	22✔
140	h.Recorder.Event(h.aw, corev1.EventTypeWarning, "CreationFailed", fmt.Sprintf("Failed to create cron workflow '%s': %v", cwf.GetName(), err))	11✔
141	return errLogAndWrap(h.log, err, "failed to create argo cron workflow")	11✔
142	}	11✔
143	} else {	1✔
144	h.Recorder.Event(h.aw, corev1.EventTypeNormal, "Created", fmt.Sprintf("Created cron workflow '%s'", cwf.GetName()))	1✔
145	}	1✔
146
147	h.aw.Status.Phase = arcv1alpha1.WorkflowPending	1✔
148	if err := h.Status().Update(ctx, h.aw); err != nil {	1✔
149	return errLogAndWrap(h.log, err, "failed to update status")	×
150	}	×
151
152	return nil	1✔
153	}
154
155	func (h *CronWorkflowHandler) CheckArgoResources(ctx context.Context) error {	14✔
156	cwf := wfv1alpha1.CronWorkflow{}	14✔
157	if err := h.Get(ctx, namespacedName(h.aw.Namespace, h.aw.Name), &cwf); err != nil {	14✔
158	return errLogAndWrap(h.log, err, "failed to get cron workflow")	×
159	}	×
160
161	updated := false	14✔
162		14✔
163	if !h.aw.Status.LastScheduled.Equal(cwf.Status.LastScheduledTime) {	15✔
164	h.aw.Status.LastScheduled = cwf.Status.LastScheduledTime	1✔
165	updated = true	1✔
166	}	1✔
167	if h.aw.Status.Failed != cwf.Status.Failed {	15✔
168	h.aw.Status.Failed = cwf.Status.Failed	1✔
169	updated = true	1✔
170	}	1✔
171	if h.aw.Status.Succeeded != cwf.Status.Succeeded {	15✔
172	h.aw.Status.Succeeded = cwf.Status.Succeeded	1✔
173	updated = true	1✔
174	}	1✔
175
176	// If the active workflow is not the same as the current one, update the reference
177	if len(cwf.Status.Active) > 0 {	26✔
178	// Should only contain a single element at most (expected to be in the same namespace!)	12✔
179	ref := cwf.Status.Active[len(cwf.Status.Active)-1]	12✔
180		12✔
181	if h.aw.Status.ActiveWorkflowRef.Name != ref.Name {	21✔
182	h.log.V(1).Info("Updating reference for cron workflow", "cronWorkflow", cwf.Name, "activeWorkflow", ref.Name)	9✔
183		9✔
184	// Get the active workflow	9✔
185	wf := wfv1alpha1.Workflow{}	9✔
186	if err := h.Get(ctx, namespacedName(h.aw.Namespace, ref.Name), &wf); err != nil {	9✔
187	return errLogAndWrap(h.log, err, "failed to fetch active workflow")	×
188	}	×
189
190	h.aw.Status.ActiveWorkflowRef = corev1.LocalObjectReference{	9✔
191	Name: wf.Name,	9✔
192	}	9✔
193	h.aw.Status.Message = ""	9✔
194	h.aw.Status.Phase = arcv1alpha1.WorkflowActive	9✔
195		9✔
196	updated = updated \|\| h.setStatusFromWorkflow(ctx, h.log, h.aw, &wf)	9✔
197	}
198	}
199
200	// If there is an active workflow, check its status
201	if h.aw.Status.ActiveWorkflowRef.Name != "" {	26✔
202	wf := wfv1alpha1.Workflow{}	12✔
203	if err := h.Get(ctx, namespacedName(h.aw.Namespace, h.aw.Status.ActiveWorkflowRef.Name), &wf); err != nil {	12✔
204	return errLogAndWrap(h.log, err, "failed to fetch active workflow")	×
205	}	×
206
207	updated = updated \|\| h.setStatusFromWorkflow(ctx, h.log, h.aw, &wf)	12✔
208		12✔
209	if wf.Status.Phase.Completed() {	21✔
210	h.aw.Status.ActiveWorkflowRef.Name = ""	9✔
211	updated = true	9✔
212	}	9✔
213	}
214
215	if !updated {	17✔
216	return nil	3✔
217	}	3✔
218
219	h.log.V(1).Info("Updating status from active workflow", "cronWorkflow", cwf.Name)	11✔
220		11✔
221	if err := h.Status().Update(ctx, h.aw); err != nil {	11✔
222	return errLogAndWrap(h.log, err, "failed to update status")	×
223	}	×
224
225	return nil	11✔
226	}
227
228	func hydrateArgoWorkflowSpec(aw arcv1alpha1.ArtifactWorkflow, srcSecret corev1.Secret, dstSecret *corev1.Secret) wfv1alpha1.WorkflowSpec {	738✔
229	srcVolume := corev1.Volume{	738✔
230	Name: "src-secret-vol",	738✔
231	VolumeSource: corev1.VolumeSource{	738✔
232	EmptyDir: &corev1.EmptyDirVolumeSource{},	738✔
233	},	738✔
234	}	738✔
235	if srcSecret.Name != "" {	1,138✔
236	srcVolume.VolumeSource = corev1.VolumeSource{	400✔
237	Secret: &corev1.SecretVolumeSource{	400✔
238	SecretName: srcSecret.Name,	400✔
239	},	400✔
240	}	400✔
241	}	400✔
242
243	dstVolume := corev1.Volume{	738✔
244	Name: "dst-secret-vol",	738✔
245	VolumeSource: corev1.VolumeSource{	738✔
246	EmptyDir: &corev1.EmptyDirVolumeSource{},	738✔
247	},	738✔
248	}	738✔
249	if dstSecret.Name != "" {	1,138✔
250	dstVolume.VolumeSource = corev1.VolumeSource{	400✔
251	Secret: &corev1.SecretVolumeSource{	400✔
252	SecretName: dstSecret.Name,	400✔
253	},	400✔
254	}	400✔
255	}	400✔
256
257	parameters := []wfv1alpha1.Parameter{}	738✔
258	for _, p := range aw.Spec.Parameters {	4,264✔
259	parameters = append(parameters, wfv1alpha1.Parameter{	3,526✔
260	Name: p.Name,	3,526✔
261	Value: (*wfv1alpha1.AnyString)(&p.Value),	3,526✔
262	})	3,526✔
263	}	3,526✔
264
265	return wfv1alpha1.WorkflowSpec{	738✔
266	WorkflowTemplateRef: &wfv1alpha1.WorkflowTemplateRef{	738✔
267	Name: aw.Spec.WorkflowTemplateRef.Name,	738✔
268	ClusterScope: aw.Spec.WorkflowTemplateRef.ClusterScope,	738✔
269	},	738✔
270	Volumes: []corev1.Volume{	738✔
271	srcVolume,	738✔
272	dstVolume,	738✔
273	},	738✔
274	Arguments: wfv1alpha1.Arguments{	738✔
275	Parameters: parameters,	738✔
276	},	738✔
277	}	738✔
278	}
279
280	func hydrateArgoWorkflow(aw arcv1alpha1.ArtifactWorkflow, srcSecret corev1.Secret, dstSecret corev1.Secret) wfv1alpha1.Workflow {	726✔
281	return &wfv1alpha1.Workflow{	726✔
282	ObjectMeta: workflowObjectMeta(aw),	726✔
283	Spec: hydrateArgoWorkflowSpec(aw, srcSecret, dstSecret),	726✔
284	}	726✔
285	}	726✔
286
287	func hydrateArgoCronWorkflow(aw arcv1alpha1.ArtifactWorkflow, srcSecret corev1.Secret, dstSecret corev1.Secret) wfv1alpha1.CronWorkflow {	12✔
288	om := workflowObjectMeta(aw)	12✔
289	wf := &wfv1alpha1.CronWorkflow{	12✔
290	ObjectMeta: om,	12✔
291	Spec: wfv1alpha1.CronWorkflowSpec{	12✔
292	WorkflowSpec: hydrateArgoWorkflowSpec(aw, srcSecret, dstSecret),	12✔
293	Schedules: aw.Spec.Cron.Schedules,	12✔
294	ConcurrencyPolicy: wfv1alpha1.ReplaceConcurrent,	12✔
295	StartingDeadlineSeconds: aw.Spec.Cron.StartingDeadlineSeconds,	12✔
296	Timezone: aw.Spec.Cron.Timezone,	12✔
297	When: aw.Spec.Cron.When,	12✔
298	SuccessfulJobsHistoryLimit: sprint.ToPointer(int32(1)),	12✔
299	FailedJobsHistoryLimit: sprint.ToPointer(int32(1)),	12✔
300	WorkflowMetadata: &om,	12✔
301	},	12✔
302	}	12✔
303		12✔
304	return wf	12✔
305	}	12✔

opendefensecloud / artifact-conduit / 21902989333

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