25554251483

Committed 08 May 2026 11:56AM UTC coverage: 84.267% (-0.1%) from 84.375%

Build # 25554251483

Build Type

push

github

Committed by

web-flow

Commit Message

chore(deps): update module osv-scanner to v2.3.8 (#348)

This PR contains the following updates:

| Package | Change |
[Age](https://docs.renovatebot.com/merge-confidence/) |
[Confidence](https://docs.renovatebot.com/merge-confidence/) |
|---|---|---|---|
| [osv-scanner](https://redirect.github.com/google/osv-scanner) |
`v2.3.7` → `v2.3.8` |
![age](https://developer.mend.io/api/mc/badges/age/go/github.com%2fgoogle%2fosv-scanner%2fv2%2fcmd%2fosv-scanner/v2.3.8?slim=true)
|
![confidence](https://developer.mend.io/api/mc/badges/confidence/go/github.com%2fgoogle%2fosv-scanner%2fv2%2fcmd%2fosv-scanner/v2.3.7/v2.3.8?slim=true)
|

---

### Release Notes

<details>
<summary>google/osv-scanner (osv-scanner)</summary>

###
[`v2.3.8`](https://redirect.github.com/google/osv-scanner/blob/HEAD/CHANGELOG.md#v237v238)

[Compare
Source](https://redirect.github.com/google/osv-scanner/compare/v2.3.7...v2.3.8)

##### Fixes:

- Fix installation issues with `go install` due to dependency conflicts
(downgrade `containerd/cgroups/v3`, `moby/buildkit` and
`opencontainers/runtime-spec`).
- [Bug
#&#8203;2762](https://redirect.github.com/google/osv-scanner/pull/2762)
Skip packages with short commit hashes instead of aborting scan.
- [Bug
#&#8203;2781](https://redirect.github.com/google/osv-scanner/pull/2781)
Secure file path handling with `os.OpenRoot`.
- [Bug
#&#8203;2766](https://redirect.github.com/google/osv-scanner/pull/2766)
Correct typos across docs, configs, and Go source.

##### Misc:

- Update osv-scalibr to `v0.4.6-0.20260504042738-9293bfa4f86f`.
- Remove replace directive
([#&#8203;2782](https://redirect.github.com/google/osv-scanner/issues/2782)).
- Update contributing.md
([#&#8203;2779](https://redirect.github.com/google/osv-scanner/issues/2779)).

</details>

---

### Configuration

📅 **Schedule**: (UTC)

- Branch creation
  - At any time (no schedule defined)
- Automerge
  - At any time (no schedule defined)

🚦 **Automerge**: Disabled by config. Please merge this... (continued)

Coverage Stats

782 of 928 relevant lines covered (84.27%)

364.36 hits per line

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

83.18

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

opendefensecloud / artifact-conduit / 25554251483

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