forked from argoproj/argo-workflows
/
create.go
114 lines (102 loc) · 3.26 KB
/
create.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package template
import (
"log"
"os"
"github.com/argoproj/pkg/json"
"github.com/spf13/cobra"
"github.com/argoproj/argo/cmd/argo/commands/client"
"github.com/argoproj/argo/cmd/server/workflowtemplate"
wfv1 "github.com/argoproj/argo/pkg/apis/workflow/v1alpha1"
"github.com/argoproj/argo/workflow/common"
"github.com/argoproj/argo/workflow/templateresolution"
"github.com/argoproj/argo/workflow/util"
"github.com/argoproj/argo/workflow/validate"
)
type cliCreateOpts struct {
output string // --output
strict bool // --strict
}
func NewCreateCommand() *cobra.Command {
var (
cliCreateOpts cliCreateOpts
)
var command = &cobra.Command{
Use: "create FILE1 FILE2...",
Short: "create a workflow template",
Run: func(cmd *cobra.Command, args []string) {
if len(args) == 0 {
cmd.HelpFunc()(cmd, args)
os.Exit(1)
}
CreateWorkflowTemplates(args, &cliCreateOpts)
},
}
command.Flags().StringVarP(&cliCreateOpts.output, "output", "o", "", "Output format. One of: name|json|yaml|wide")
command.Flags().BoolVar(&cliCreateOpts.strict, "strict", true, "perform strict workflow validation")
return command
}
func CreateWorkflowTemplates(filePaths []string, cliOpts *cliCreateOpts) {
if cliOpts == nil {
cliOpts = &cliCreateOpts{}
}
defaultWFTmplClient := InitWorkflowTemplateClient()
fileContents, err := util.ReadManifest(filePaths...)
if err != nil {
log.Fatal(err)
}
var workflowTemplates []wfv1.WorkflowTemplate
for _, body := range fileContents {
wftmpls := unmarshalWorkflowTemplates(body, cliOpts.strict)
workflowTemplates = append(workflowTemplates, wftmpls...)
}
if len(workflowTemplates) == 0 {
log.Println("No workflow template found in given files")
os.Exit(1)
}
for _, wftmpl := range workflowTemplates {
var created *wfv1.WorkflowTemplate
if client.ArgoServer != "" {
ns, _, _ := client.Config.Namespace()
wftmplReq := workflowtemplate.WorkflowTemplateCreateRequest{
Namespace: ns,
Template: &wftmpl,
}
conn := client.GetClientConn()
wftmplApiClient, ctx := GetWFtmplApiServerGRPCClient(conn)
created, err = wftmplApiClient.CreateWorkflowTemplate(ctx, &wftmplReq)
} else {
wftmplGetter := templateresolution.WrapWorkflowTemplateInterface(wftmplClient)
err = validate.ValidateWorkflowTemplate(wftmplGetter, &wftmpl)
if err != nil {
log.Fatalf("Failed to create workflow template: %v", err)
}
wftmplClient := defaultWFTmplClient
if wftmpl.Namespace != "" {
wftmplClient = InitWorkflowTemplateClient(wftmpl.Namespace)
}
created, err = wftmplClient.Create(&wftmpl)
}
if err != nil {
log.Fatalf("Failed to create workflow template: %v", err)
}
printWorkflowTemplate(created, cliOpts.output)
}
}
// unmarshalWorkflowTemplates unmarshals the input bytes as either json or yaml
func unmarshalWorkflowTemplates(wfBytes []byte, strict bool) []wfv1.WorkflowTemplate {
var wf wfv1.WorkflowTemplate
var jsonOpts []json.JSONOpt
if strict {
jsonOpts = append(jsonOpts, json.DisallowUnknownFields)
}
err := json.Unmarshal(wfBytes, &wf, jsonOpts...)
if err == nil {
return []wfv1.WorkflowTemplate{wf}
}
yamlWfs, err := common.SplitWorkflowTemplateYAMLFile(wfBytes, strict)
if err == nil {
return yamlWfs
}
log.Fatalf("Failed to parse workflow template: %v", err)
return nil
}