-
Notifications
You must be signed in to change notification settings - Fork 298
/
resources.go
135 lines (110 loc) · 3.72 KB
/
resources.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
package config
import (
"fmt"
"github.com/pkg/errors"
"go.starlark.net/starlark"
"github.com/tilt-dev/tilt/internal/sliceutils"
"github.com/tilt-dev/tilt/internal/tiltfile/starkit"
"github.com/tilt-dev/tilt/internal/tiltfile/value"
"github.com/tilt-dev/tilt/pkg/model"
)
func setEnabledResources(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
var slResources starlark.Sequence
err := starkit.UnpackArgs(thread, fn.Name(), args, kwargs,
"resources",
&slResources,
)
if err != nil {
return starlark.None, err
}
resources, err := value.SequenceToStringSlice(slResources)
if err != nil {
return starlark.None, errors.Wrap(err, "resources must be a list of string")
}
var mns []model.ManifestName
for _, r := range resources {
mns = append(mns, model.ManifestName(r))
}
err = starkit.SetState(thread, func(settings Settings) Settings {
settings.enabledResources = mns
return settings
})
if err != nil {
return starlark.None, err
}
return starlark.None, nil
}
// for the given args and list of full manifests, figure out which manifests the user actually selected
func (s Settings) EnabledResources(manifests []model.Manifest) ([]model.Manifest, error) {
// if the user called set_enabled_resources, that trumps everything
if s.enabledResources != nil {
return match(manifests, s.enabledResources)
}
args := s.userConfigState.Args
// if the user has not called config.parse and has specified args, use those to select which resources
if args != nil && !s.configParseCalled {
var mns []model.ManifestName
for _, arg := range args {
mns = append(mns, model.ManifestName(arg))
}
return match(manifests, mns)
}
// otherwise, they get all resources
return manifests, nil
}
// add `manifestToAdd` and all of its transitive deps to `result`
func addManifestAndDeps(result map[model.ManifestName]bool, allManifestsByName map[model.ManifestName]model.Manifest, manifestToAdd model.ManifestName) {
if result[manifestToAdd] {
return
}
result[manifestToAdd] = true
for _, dep := range allManifestsByName[manifestToAdd].ResourceDependencies {
addManifestAndDeps(result, allManifestsByName, dep)
}
}
// If the user requested only a subset of manifests, get just those manifests
func match(manifests []model.Manifest, requestedManifests []model.ManifestName) ([]model.Manifest, error) {
if len(requestedManifests) == 0 {
return manifests, nil
}
manifestsByName := make(map[model.ManifestName]model.Manifest)
for _, m := range manifests {
manifestsByName[m.Name] = m
}
manifestsToRun := make(map[model.ManifestName]bool)
var unknownNames []string
for _, m := range requestedManifests {
if _, ok := manifestsByName[m]; !ok {
unknownNames = append(unknownNames, string(m))
continue
}
addManifestAndDeps(manifestsToRun, manifestsByName, m)
}
var result []model.Manifest
for _, m := range manifests {
if manifestsToRun[m.Name] {
result = append(result, m)
}
}
if len(unknownNames) > 0 {
unmatchedNames := unmatchedManifestNames(manifests, requestedManifests)
return nil, fmt.Errorf(`You specified some resources that could not be found: %s
Is this a typo? Existing resources in Tiltfile: %s`,
sliceutils.QuotedStringList(unknownNames),
sliceutils.QuotedStringList(unmatchedNames))
}
return result, nil
}
func unmatchedManifestNames(manifests []model.Manifest, requestedManifests []model.ManifestName) []string {
requestedManifestsByName := make(map[model.ManifestName]bool)
for _, m := range requestedManifests {
requestedManifestsByName[m] = true
}
var ret []string
for _, m := range manifests {
if _, ok := requestedManifestsByName[m.Name]; !ok {
ret = append(ret, string(m.Name))
}
}
return ret
}