mirror of https://github.com/knative/func.git
94 lines
2.6 KiB
Go
94 lines
2.6 KiB
Go
package function
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"gopkg.in/yaml.v2"
|
|
)
|
|
|
|
// ConfigFile is the name of the config's serialized form.
|
|
const ConfigFile = "func.yaml"
|
|
|
|
// Config represents the serialized state of a Function's metadata.
|
|
// See the Function struct for attribute documentation.
|
|
type config struct {
|
|
Name string `yaml:"name"`
|
|
Namespace string `yaml:"namespace"`
|
|
Runtime string `yaml:"runtime"`
|
|
Image string `yaml:"image"`
|
|
ImageDigest string `yaml:"imageDigest"`
|
|
Trigger string `yaml:"trigger"`
|
|
Builder string `yaml:"builder"`
|
|
BuilderMap map[string]string `yaml:"builderMap"`
|
|
Env map[string]string `yaml:"env"`
|
|
Annotations map[string]string `yaml:"annotations"`
|
|
// Add new values to the toConfig/fromConfig functions.
|
|
}
|
|
|
|
// newConfig returns a Config populated from data serialized to disk if it is
|
|
// available. Errors are returned if the path is not valid, if there are
|
|
// errors accessing an extant config file, or the contents of the file do not
|
|
// unmarshall. A missing file at a valid path does not error but returns the
|
|
// empty value of Config.
|
|
func newConfig(root string) (c config, err error) {
|
|
filename := filepath.Join(root, ConfigFile)
|
|
if _, err = os.Stat(filename); err != nil {
|
|
// do not consider a missing config file an error. Just return.
|
|
if os.IsNotExist(err) {
|
|
err = nil
|
|
}
|
|
return
|
|
}
|
|
bb, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return
|
|
}
|
|
err = yaml.Unmarshal(bb, &c)
|
|
return
|
|
}
|
|
|
|
// fromConfig returns a Function populated from config.
|
|
// Note that config does not include ancillary fields not serialized, such as Root.
|
|
func fromConfig(c config) (f Function) {
|
|
return Function{
|
|
Name: c.Name,
|
|
Namespace: c.Namespace,
|
|
Runtime: c.Runtime,
|
|
Image: c.Image,
|
|
ImageDigest: c.ImageDigest,
|
|
Trigger: c.Trigger,
|
|
Builder: c.Builder,
|
|
BuilderMap: c.BuilderMap,
|
|
Env: c.Env,
|
|
Annotations: c.Annotations,
|
|
}
|
|
}
|
|
|
|
// toConfig serializes a Function to a config object.
|
|
func toConfig(f Function) config {
|
|
return config{
|
|
Name: f.Name,
|
|
Namespace: f.Namespace,
|
|
Runtime: f.Runtime,
|
|
Image: f.Image,
|
|
ImageDigest: f.ImageDigest,
|
|
Trigger: f.Trigger,
|
|
Builder: f.Builder,
|
|
BuilderMap: f.BuilderMap,
|
|
Env: f.Env,
|
|
Annotations: f.Annotations,
|
|
}
|
|
}
|
|
|
|
// writeConfig for the given Function out to disk at root.
|
|
func writeConfig(f Function) (err error) {
|
|
path := filepath.Join(f.Root, ConfigFile)
|
|
c := toConfig(f)
|
|
var bb []byte
|
|
if bb, err = yaml.Marshal(&c); err != nil {
|
|
return
|
|
}
|
|
return os.WriteFile(path, bb, 0644)
|
|
}
|