forked from donny-dont/drone-exec
-
Notifications
You must be signed in to change notification settings - Fork 0
/
parse.go
145 lines (127 loc) · 2.83 KB
/
parse.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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
package parser
import "github.com/drone/drone-exec/yaml"
// Tree is the representation of a parsed build
// configuraiton Yaml file.
type Tree struct {
Root *ListNode
rules []RuleFunc
}
// newTree allocates a new parse tree.
func newTree(rules []RuleFunc) *Tree {
return &Tree{
Root: &ListNode{NodeType: NodeList},
rules: rules,
}
}
// Parse parses the Yaml build definition file
// and returns an execution Tree.
func Parse(raw string, rules []RuleFunc) (*Tree, error) {
conf, err := yaml.ParseString(raw)
if err != nil {
return nil, err
}
return Load(conf, rules)
}
// Load loads the Yaml build definition structure
// and returns an execution Tree.
func Load(conf *yaml.Config, rules []RuleFunc) (*Tree, error) {
var tree = newTree(rules)
var err error
// Cache.
err = tree.appendCache(conf.Cache)
if err != nil {
return nil, err
}
// Clone.
err = tree.appendPlugin(NodeClone, conf.Clone)
if err != nil {
return nil, err
}
// Compose.
err = tree.appendCompose(conf.Compose.Slice())
if err != nil {
return nil, err
}
// Build
err = tree.appendBuild(conf.Build.Slice())
if err != nil {
return nil, err
}
// Publish.
err = tree.appendPlugin(NodePublish, conf.Publish.Slice()...)
if err != nil {
return nil, err
}
// Deploy.
err = tree.appendPlugin(NodeDeploy, conf.Deploy.Slice()...)
if err != nil {
return nil, err
}
// Plugin.
err = tree.appendPlugin(NodeNotify, conf.Notify.Slice()...)
if err != nil {
return nil, err
}
return tree, nil
}
func (t *Tree) appendPlugin(typ NodeType, plugins ...yaml.Plugin) error {
for _, plugin := range plugins {
node := newPluginNode(typ, plugin)
for _, rule := range t.rules {
err := rule(node)
if err != nil {
return err
}
}
fnode := newFilterNode(plugin.Filter)
fnode.Node = node
// TODO: we should apply rules to all nodes in
// the tree AFTER the entire tree is constructed.
for _, rule := range t.rules {
err := rule(fnode)
if err != nil {
return err
}
}
t.Root.append(fnode)
}
return nil
}
func (t *Tree) appendBuild(builds []yaml.Build) error {
for _, build := range builds {
node := newBuildNode(NodeBuild, build)
for _, rule := range t.rules {
if err := rule(node); err != nil {
return err
}
}
fnode := newFilterNode(build.Filter)
fnode.Node = node
for _, rule := range t.rules {
if err := rule(fnode); err != nil {
return err
}
}
t.Root.append(fnode)
}
return nil
}
func (t *Tree) appendCache(cache yaml.Plugin) error {
if len(cache.Vargs) == 0 {
return nil
}
return t.appendPlugin(NodeCache, cache)
}
func (t *Tree) appendCompose(plugins []yaml.Container) error {
for _, plugin := range plugins {
node := newDockerNode(NodeCompose, plugin)
for _, rule := range t.rules {
err := rule(node)
if err != nil {
return err
}
}
t.Root.append(node)
}
return nil
}