Skip to content

Commit 3a23abc

Browse files
JordanGoasdoueJordanGoasdoue
committed
chore: support v1 and v1beta1
1 parent e0450a6 commit 3a23abc

File tree

1 file changed

+110
-84
lines changed

1 file changed

+110
-84
lines changed

‎pkg/triggerconfig/inrepo/load_pipelinerun.go

+110-84
Original file line numberDiff line numberDiff line change
@@ -13,13 +13,15 @@ import (
1313

1414
"github.com/pkg/errors"
1515
pipelinev1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1"
16+
pipelinev1beta1 "github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1"
1617
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
1718
"sigs.k8s.io/yaml"
1819
)
1920

2021
const (
2122
// TektonAPIVersion the default tekton API version
22-
TektonAPIVersion = "tekton.dev/v1"
23+
TektonAPIVersion = "tekton.dev/v1"
24+
TektonAPIVersionV1B1 = "tekton.dev/v1beta1"
2325

2426
// DefaultParameters the annotation used to disable default parameters
2527
DefaultParameters = "lighthouse.jenkins-x.io/defaultParameters"
@@ -75,126 +77,150 @@ func LoadTektonResourceAsPipelineRun(resolver *UsesResolver, data []byte) (*pipe
7577
}
7678
message := resolver.Message
7779
dir := resolver.Dir
78-
kindPrefix := "kind:"
79-
kind := "PipelineRun"
80-
lines := strings.Split(string(data), "\n")
81-
for _, line := range lines {
82-
if !strings.HasPrefix(line, kindPrefix) {
83-
continue
84-
}
85-
k := strings.TrimSpace(line[len(kindPrefix):])
86-
if k != "" {
87-
kind = k
88-
break
89-
}
80+
81+
var meta struct {
82+
Kind string `yaml:"kind"`
83+
APIVersion string `yaml:"apiVersion"`
9084
}
91-
switch kind {
85+
if err := yaml.Unmarshal(data, &meta); err != nil {
86+
return nil, errors.Wrapf(err, "failed to extract metadata (kind, apiVersion) from YAML %s", message)
87+
}
88+
89+
isBeta := meta.APIVersion == TektonAPIVersionV1B1
90+
91+
switch meta.Kind {
9292
case "Pipeline":
9393
pipeline := &pipelinev1.Pipeline{}
94-
err := yaml.Unmarshal(data, pipeline)
95-
if err != nil {
96-
return nil, errors.Wrapf(err, "failed to unmarshal Pipeline YAML %s", message)
94+
var err error
95+
if isBeta {
96+
pipeline, err = unmarshalAndConvertPipeline(data, message)
97+
} else {
98+
err = yaml.Unmarshal(data, pipeline)
9799
}
98-
prs, err := ConvertPipelineToPipelineRun(pipeline, resolver.Message, resolver.DefaultValues)
99100
if err != nil {
100-
return prs, err
101+
return nil, err
101102
}
102-
re, err := loadTektonRefsFromFilesPattern(prs)
103+
prs, err := ConvertPipelineToPipelineRun(pipeline, resolver.Message, resolver.DefaultValues)
103104
if err != nil {
104105
return prs, err
105106
}
106-
if re != nil {
107-
prs, err = loadPipelineRunRefs(resolver, prs, dir, message, re)
108-
if err != nil {
109-
return prs, err
110-
}
111-
}
112-
prs, err = inheritTaskSteps(resolver, prs)
113-
if err != nil {
114-
return prs, errors.Wrapf(err, "failed to inherit steps")
115-
}
116-
return DefaultPipelineParameters(prs)
107+
return resolvePipelineRunReferences(resolver, prs, dir, message)
117108

118109
case "PipelineRun":
119110
prs := &pipelinev1.PipelineRun{}
120-
err := yaml.Unmarshal(data, prs)
121-
if err != nil {
122-
return nil, errors.Wrapf(err, "failed to unmarshal PipelineRun YAML %s", message)
123-
}
124-
125-
re, err := loadTektonRefsFromFilesPattern(prs)
126-
if err != nil {
127-
return prs, err
128-
}
129-
if re != nil {
130-
prs, err = loadPipelineRunRefs(resolver, prs, dir, message, re)
131-
if err != nil {
132-
return prs, err
133-
}
111+
var err error
112+
if isBeta {
113+
prs, err = unmarshalAndConvertPipelineRun(data, message)
114+
} else {
115+
err = yaml.Unmarshal(data, prs)
134116
}
135-
prs, err = inheritTaskSteps(resolver, prs)
136117
if err != nil {
137-
return prs, errors.Wrap(err, "failed to inherit steps")
118+
return nil, err
138119
}
139-
return DefaultPipelineParameters(prs)
120+
return resolvePipelineRunReferences(resolver, prs, dir, message)
140121

141122
case "Task":
142123
task := &pipelinev1.Task{}
143-
err := yaml.Unmarshal(data, task)
144-
if err != nil {
145-
return nil, errors.Wrapf(err, "failed to unmarshal Task YAML %s", message)
124+
var err error
125+
if isBeta {
126+
task, err = unmarshalAndConvertTask(data, message)
127+
} else {
128+
err = yaml.Unmarshal(data, task)
146129
}
147-
prs, err := ConvertTaskToPipelineRun(task, message, resolver.DefaultValues)
148130
if err != nil {
149-
return prs, err
131+
return nil, err
150132
}
151-
re, err := loadTektonRefsFromFilesPattern(prs)
133+
prs, err := ConvertTaskToPipelineRun(task, message, resolver.DefaultValues)
152134
if err != nil {
153135
return prs, err
154136
}
155-
if re != nil {
156-
prs, err = loadPipelineRunRefs(resolver, prs, dir, message, re)
157-
if err != nil {
158-
return prs, err
159-
}
160-
}
161-
prs, err = inheritTaskSteps(resolver, prs)
162-
if err != nil {
163-
return prs, errors.Wrapf(err, "failed to inherit steps")
164-
}
165-
defaultTaskName(prs)
166-
return DefaultPipelineParameters(prs)
137+
return resolvePipelineRunReferences(resolver, prs, dir, message)
167138

168139
case "TaskRun":
169140
tr := &pipelinev1.TaskRun{}
170-
err := yaml.Unmarshal(data, tr)
141+
var err error
142+
if isBeta {
143+
tr, err = unmarshalAndConvertTaskRun(data, message)
144+
} else {
145+
err = yaml.Unmarshal(data, tr)
146+
}
171147
if err != nil {
172-
return nil, errors.Wrapf(err, "failed to unmarshal TaskRun YAML %s", message)
148+
return nil, err
173149
}
174150
prs, err := ConvertTaskRunToPipelineRun(tr, message, resolver.DefaultValues)
175151
if err != nil {
176152
return prs, err
177153
}
178-
re, err := loadTektonRefsFromFilesPattern(prs)
179-
if err != nil {
154+
return resolvePipelineRunReferences(resolver, prs, dir, message)
155+
156+
default:
157+
return nil, errors.Errorf("kind %s is not supported for %s", meta.Kind, message)
158+
}
159+
}
160+
161+
func unmarshalAndConvertPipeline(data []byte, message string) (*pipelinev1.Pipeline, error) {
162+
pV1Beta1 := &pipelinev1beta1.Pipeline{}
163+
if err := yaml.Unmarshal(data, pV1Beta1); err != nil {
164+
return nil, errors.Wrapf(err, "failed to unmarshal Pipeline v1beta1 YAML %s", message)
165+
}
166+
pV1 := &pipelinev1.Pipeline{}
167+
if err := pV1Beta1.ConvertTo(context.TODO(), pV1); err != nil {
168+
return nil, errors.Wrap(err, "failed to convert Pipeline from v1beta1 to v1")
169+
}
170+
return pV1, nil
171+
}
172+
173+
func unmarshalAndConvertPipelineRun(data []byte, message string) (*pipelinev1.PipelineRun, error) {
174+
prsV1Beta1 := &pipelinev1beta1.PipelineRun{}
175+
if err := yaml.Unmarshal(data, prsV1Beta1); err != nil {
176+
return nil, errors.Wrapf(err, "failed to unmarshal PipelineRun v1beta1 YAML %s", message)
177+
}
178+
prsV1 := &pipelinev1.PipelineRun{}
179+
if err := prsV1Beta1.ConvertTo(context.TODO(), prsV1); err != nil {
180+
return nil, errors.Wrap(err, "failed to convert PipelineRun from v1beta1 to v1")
181+
}
182+
return prsV1, nil
183+
}
184+
185+
func unmarshalAndConvertTask(data []byte, message string) (*pipelinev1.Task, error) {
186+
tV1Beta1 := &pipelinev1beta1.Task{}
187+
if err := yaml.Unmarshal(data, tV1Beta1); err != nil {
188+
return nil, errors.Wrapf(err, "failed to unmarshal Task v1beta1 YAML %s", message)
189+
}
190+
tV1 := &pipelinev1.Task{}
191+
if err := tV1Beta1.ConvertTo(context.TODO(), tV1); err != nil {
192+
return nil, errors.Wrap(err, "failed to convert Task from v1beta1 to v1")
193+
}
194+
return tV1, nil
195+
}
196+
197+
func unmarshalAndConvertTaskRun(data []byte, message string) (*pipelinev1.TaskRun, error) {
198+
trsV1Beta1 := &pipelinev1beta1.TaskRun{}
199+
if err := yaml.Unmarshal(data, trsV1Beta1); err != nil {
200+
return nil, errors.Wrapf(err, "failed to unmarshal TaskRun v1beta1 YAML %s", message)
201+
}
202+
trsV1 := &pipelinev1.TaskRun{}
203+
if err := trsV1Beta1.ConvertTo(context.TODO(), trsV1); err != nil {
204+
return nil, errors.Wrap(err, "failed to convert TaskRun from v1beta1 to v1")
205+
}
206+
return trsV1, nil
207+
}
208+
209+
func resolvePipelineRunReferences(resolver *UsesResolver, prs *pipelinev1.PipelineRun, dir, message string) (*pipelinev1.PipelineRun, error) {
210+
if re, err := loadTektonRefsFromFilesPattern(prs); err != nil {
211+
return prs, err
212+
} else if re != nil {
213+
if prs, err = loadPipelineRunRefs(resolver, prs, dir, message, re); err != nil {
180214
return prs, err
181215
}
182-
if re != nil {
183-
prs, err = loadPipelineRunRefs(resolver, prs, dir, message, re)
184-
if err != nil {
185-
return prs, err
186-
}
187-
}
188-
prs, err = inheritTaskSteps(resolver, prs)
189-
if err != nil {
190-
return prs, errors.Wrapf(err, "failed to inherit steps")
191-
}
192-
defaultTaskName(prs)
193-
return DefaultPipelineParameters(prs)
216+
}
194217

195-
default:
196-
return nil, errors.Errorf("kind %s is not supported for %s", kind, message)
218+
if prs, err := inheritTaskSteps(resolver, prs); err != nil {
219+
return prs, errors.Wrapf(err, "failed to inherit steps")
197220
}
221+
222+
defaultTaskName(prs) // Renamed function for clarity
223+
return DefaultPipelineParameters(prs)
198224
}
199225

200226
func defaultTaskName(prs *pipelinev1.PipelineRun) {

0 commit comments

Comments
 (0)