forked from knative/func
-
Notifications
You must be signed in to change notification settings - Fork 0
/
function.go
291 lines (254 loc) · 9.7 KB
/
function.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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
package faas
import (
"errors"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"golang.org/x/net/publicsuffix"
)
type Function struct {
// Root on disk at which to find/create source and config files.
Root string
// Name of the Function. If not provided, path derivation is attempted when
// requried (such as for initialization).
Name string
// Namespace into which the Function is deployed on supported platforms.
Namespace string
// Runtime is the language plus context. nodejs|go|quarkus|rust etc.
Runtime string
// Trigger of the Function. http|events etc.
Trigger string
// Repository at which to store interstitial containers, in the form
// [registry]/[user]. If omitted, "Image" must be provided.
Repo string
// Optional full OCI image tag in form:
// [registry]/[namespace]/[name]:[tag]
// example:
// quay.io/alice/my.function.name
// Registry is optional and is defaulted to DefaultRegistry
// example:
// alice/my.function.name
// If Image is provided, it overrides the default of concatenating
// "Repo+Name:latest" to derive the Image.
Image string
}
// NewFunction loads a Function from a path on disk. use .Initialized() to determine if
// the path contained an initialized Function.
// NewFunction creates a Function struct whose attributes are loaded from the
// configuraiton located at path.
func NewFunction(root string) (f Function, err error) {
// Expand the passed root to its absolute path (default current dir)
if root, err = filepath.Abs(root); err != nil {
return
}
// Load a Config from the given absolute path
c, err := newConfig(root)
if err != nil {
return
}
// set Function to the value of the config loaded from disk.
f = fromConfig(c)
// The only value not included in the config is the effective path on disk
f.Root = root
return
}
// WriteConfig writes this Function's configuration to disk.
func (f Function) WriteConfig() (err error) {
return writeConfig(f)
}
// Initialized returns if the Function has been initialized.
// Any errors are considered failure (invalid or inaccessible root, config file, etc).
func (f Function) Initialized() bool {
// Load the Function's configuration from disk and check if the (required) value Runtime is populated.
c, err := newConfig(f.Root)
if err != nil {
return false
}
return c.Name != "" // TODO: use a dedicated initialized bool?
}
// DerivedImage returns the derived image name (OCI container tag) of the
// Function whose source is at root, with the default repository for when
// the image has to be calculated (derived).
// repository can be either with or without prefixed registry.
// The following are eqivalent due to the use of DefaultRegistry:
// repository: docker.io/myname
// myname
// A full image name consists of registry, repository, name and tag.
// in form [registry]/[repository]/[name]:[tag]
// example docker.io/alice/my.example.func:latest
// Default if not provided is --repository (a required global setting)
// followed by the provided (or derived) image name.
func DerivedImage(root, repository string) (image string, err error) {
// Repository is currently required until such time as we support
// pushing to an implicitly-available in-cluster registry by default.
if repository == "" {
err = errors.New("Repository name is required.")
return
}
f, err := NewFunction(root)
if err != nil {
// an inability to load the Function means it is not yet initialized
// We could try to be smart here and fall through to the Function name
// deriviation logic, but that's likely to be confusing. Better to
// stay simple and say that derivation of Image depends on first having
// the Function initialized.
return
}
// If the Function has already had image populated, use this pre-calculated value.
if f.Image != "" {
image = f.Image
return
}
// If the Function loaded, and there is not yet an Image set, then this is
// the first build and no explicit image override was specified. We should
// therefore derive the image tag from the defined repository and name.
// form: [registry]/[user]/[function]:latest
// example: quay.io/alice/my.function.name:latest
repository = strings.Trim(repository, "/") // too defensive?
repositoryTokens := strings.Split(repository, "/")
if len(repositoryTokens) == 1 {
image = DefaultRegistry + "/" + repository + "/" + f.Name
} else if len(repositoryTokens) == 2 {
image = repository + "/" + f.Name
} else {
err = fmt.Errorf("repository should be either 'namespace' or 'registry/namespace'")
}
// Explicitly append :latest. We currently expect source control to drive
// versioning, rather than rely on Docker Hub tags with explicit version
// numbers, as is seen in many serverless solutions. This will be updated
// to branch name when we add source-driven canary/ bluegreen deployments.
image = image + ":latest"
return
}
// DerivedName returns a name derived from the path, limited in its upward
// recursion along path to searchLimit.
func DerivedName(root string, searchLimit int) (string, error) {
root, err := filepath.Abs(root)
if err != nil {
return "", err
}
return pathToDomain(root, searchLimit), nil
}
// assertEmptyRoot ensures that the directory is empty enough to be used for
// initializing a new Function.
func assertEmptyRoot(path string) (err error) {
// If there exists contentious files (congig files for instance), this Function may have already been initialized.
files, err := contentiousFilesIn(path)
if err != nil {
return
} else if len(files) > 0 {
return fmt.Errorf("The chosen directory '%v' contains contentious files: %v. Has the Service Function already been created? Try either using a different directory, deleting the Function if it exists, or manually removing the files.", path, files)
}
// Ensure there are no non-hidden files, and again none of the aforementioned contentious files.
empty, err := isEffectivelyEmpty(path)
if err != nil {
return
} else if !empty {
err = errors.New("The directory must be empty of visible files and recognized config files before it can be initialized.")
return
}
return
}
// contentiousFiles are files which, if extant, preclude the creation of a
// Function rooted in the given directory.
var contentiousFiles = []string{
ConfigFile,
".appsody-config.yaml",
}
// contentiousFilesIn the given directoy
func contentiousFilesIn(dir string) (contentious []string, err error) {
files, err := ioutil.ReadDir(dir)
for _, file := range files {
for _, name := range contentiousFiles {
if file.Name() == name {
contentious = append(contentious, name)
}
}
}
return
}
// effectivelyEmpty directories are those which have no visible files
func isEffectivelyEmpty(dir string) (bool, error) {
// Check for any non-hidden files
files, err := ioutil.ReadDir(dir)
if err != nil {
return false, err
}
for _, file := range files {
if !strings.HasPrefix(file.Name(), ".") {
return false, nil
}
}
return true, nil
}
// Convert a path to a domain.
// Searches up the path string until a domain (TLD+1) is detected.
// Subdirectories are considered subdomains.
// Ex: Path: "/home/users/jane/src/example.com/admin/www"
// Returns: "www.admin.example.com"
// maxLevels is the number of directories to walk upwards beyond the current
// directory to determine domain (i.e. current directory is always considered.
// Zero indicates only consider last path element.)
func pathToDomain(path string, maxLevels int) string {
var (
// parts of the path, separated by os separator
parts = strings.Split(path, string(os.PathSeparator))
// subdomains derived from the path
subdomains []string
// domain derived from the path
domain string
)
// Loop over parts from back to front (recursing upwards), building
// optional subdomains until a root domain (TLD+1) is detected.
for i := len(parts) - 1; i >= 0; i-- {
part := parts[i]
// Support limited recursion
// Tests, for instance, need to be allowed to reliably fail by having their
// recursion contained within ./testdata if recursion is set to -1, there
// is no limit. 0 indicates only the current directory is considered.
iteration := len(parts) - 1 - i
if maxLevels >= 0 && iteration > maxLevels {
break
}
// Detect TLD+1
// If the current directory has a valid TLD plus one, it is a match.
// This is determined by using the public suffices list, which includes
// both ICANN managed TLDs as well as an extended list (matching, for
// instance 'cluster.local')
if suffix, _ := publicsuffix.EffectiveTLDPlusOne(part); suffix != "" {
domain = part
break // no directories above the nearest TLD+1 should be considered.
}
// Skip blanks
// Path elements which are blank, such as in the case of a trailing slash
// are ignored and the recursion continues, effectively collapsing ex: '//'.
if part == "" {
continue
}
// Build subdomain
// Each path element which appears before the TLD+1 is a subdomain.
// ex: '/home/users/jane/src/example.com/us-west-2/admin/www' creates the
// subdomain []string{'www', 'admin', 'us-west-2'}
subdomains = append(subdomains, part)
}
// Unable to derive domain
// If the entire path was searched, but no parts matched a TLD+1, the domain
// will be blank. In this case, the path was insufficient to derive a domain
// ex "/home/users/jane/src/test" contains no TLD, thus the final domain must
// be explicitly provided.
if domain == "" {
return ""
}
// Prepend subdomains
// If the path was a subdirectory within a TLD+1, these sudbomains
// are prepended to the TLD+1 to create the final domain.
// ex: '/home/users/jane/src/example.com/us-west-2/admin/www' yields
// www.admin.use-west-2.example.com
if len(subdomains) > 0 {
subdomains = append(subdomains, domain)
return strings.Join(subdomains, ".")
}
return domain
}