From 84e61c03912af7519f4a60cd50f7c5680a313565 Mon Sep 17 00:00:00 2001 From: Matt Butcher Date: Tue, 26 Jan 2016 17:46:58 -0700 Subject: [PATCH] Add chart file support. Also added a log abstraction. --- chart/chart.go | 107 ++++++++++++++++++++++++++++++++++++ chart/chart_test.go | 117 ++++++++++++++++++++++++++++++++++++++++ chart/chartfile.go | 79 +++++++++++++++++++++++++++ chart/chartfile_test.go | 60 +++++++++++++++++++++ glide.lock | 51 ++++++++++++++++++ glide.yaml | 11 ++++ log/log.go | 51 ++++++++++++++++++ log/log_test.go | 49 +++++++++++++++++ 8 files changed, 525 insertions(+) create mode 100644 chart/chart.go create mode 100644 chart/chart_test.go create mode 100644 chart/chartfile.go create mode 100644 chart/chartfile_test.go create mode 100644 glide.lock create mode 100644 glide.yaml create mode 100644 log/log.go create mode 100644 log/log_test.go diff --git a/chart/chart.go b/chart/chart.go new file mode 100644 index 000000000..608f98769 --- /dev/null +++ b/chart/chart.go @@ -0,0 +1,107 @@ +package chart + +import ( + "fmt" + "os" + "path/filepath" + + "github.com/helm/helm/manifest" +) + +// Chart represents a complete chart. +// +// A chart consists of the following parts: +// +// - Chart.yaml: In code, we refer to this as the Chartfile +// - manifests/*.yaml: The Kubernetes manifests +// +// On the Chart object, the manifests are sorted by type into a handful of +// recognized Kubernetes API v1 objects. +// +// TODO: Investigate treating these as unversioned. +type Chart struct { + Chartfile *Chartfile + + // Kind is a map of Kind to an array of manifests. + // + // For example, Kind["Pod"] has an array of Pod manifests. + Kind map[string][]*manifest.Manifest + + // Manifests is an array of Manifest objects. + Manifests []*manifest.Manifest +} + +// Load loads an entire chart. +// +// This includes the Chart.yaml (*Chartfile) and all of the manifests. +// +// If you are just reading the Chart.yaml file, it is substantially more +// performant to use LoadChartfile. +func Load(chart string) (*Chart, error) { + if fi, err := os.Stat(chart); err != nil { + return nil, err + } else if !fi.IsDir() { + return nil, fmt.Errorf("Chart %s is not a directory.", chart) + } + + cf, err := LoadChartfile(filepath.Join(chart, "Chart.yaml")) + if err != nil { + return nil, err + } + + c := &Chart{ + Chartfile: cf, + Kind: map[string][]*manifest.Manifest{}, + } + + ms, err := manifest.ParseDir(chart) + if err != nil { + return c, err + } + + c.attachManifests(ms) + + return c, nil +} + +const ( + // AnnFile is the annotation key for a file's origin. + AnnFile = "chart.helm.sh/file" + + // AnnChartVersion is the annotation key for a chart's version. + AnnChartVersion = "chart.helm.sh/version" + + // AnnChartDesc is the annotation key for a chart's description. + AnnChartDesc = "chart.helm.sh/description" + + // AnnChartName is the annotation key for a chart name. + AnnChartName = "chart.helm.sh/name" +) + +// attachManifests sorts manifests into their respective categories, adding to the Chart. +func (c *Chart) attachManifests(manifests []*manifest.Manifest) { + c.Manifests = manifests + for _, m := range manifests { + c.Kind[m.Kind] = append(c.Kind[m.Kind], m) + } +} + +// UnknownKinds returns a list of kinds that this chart contains, but which were not in the passed in array. +// +// A Chart will store all kinds that are given to it. This makes it possible to get a list of kinds that are not +// known beforehand. +func (c *Chart) UnknownKinds(known []string) []string { + lookup := make(map[string]bool, len(known)) + for _, k := range known { + lookup[k] = true + } + + u := []string{} + for n := range c.Kind { + if _, ok := lookup[n]; !ok { + u = append(u, n) + } + } + + return u +} diff --git a/chart/chart_test.go b/chart/chart_test.go new file mode 100644 index 000000000..c914ee8f3 --- /dev/null +++ b/chart/chart_test.go @@ -0,0 +1,117 @@ +package chart + +import ( + "testing" +) + +const testfile = "../testdata/test-Chart.yaml" +const testchart = "../testdata/charts/kitchensink" + +func TestLoad(t *testing.T) { + c, err := Load(testchart) + if err != nil { + t.Errorf("Failed to load chart: %s", err) + } + + if c.Chartfile.Name != "kitchensink" { + t.Errorf("Expected chart name to be 'kitchensink'. Got '%s'.", c.Chartfile.Name) + } + if c.Chartfile.Dependencies[0].Version != "~10.21" { + d := c.Chartfile.Dependencies[0].Version + t.Errorf("Expected dependency 0 to have version '~10.21'. Got '%s'.", d) + } + + if len(c.Kind["Pod"]) != 3 { + t.Errorf("Expected 3 pods, got %d", len(c.Kind["Pod"])) + } + + if len(c.Kind["ReplicationController"]) == 0 { + t.Error("No RCs found") + } + if len(c.Kind["Namespace"]) == 0 { + t.Errorf("No namespaces found") + } + + if len(c.Kind["Secret"]) == 0 { + t.Error("Is it secret? Is it safe? NO!") + } + + if len(c.Kind["PersistentVolume"]) == 0 { + t.Errorf("No volumes.") + } + + if len(c.Kind["Service"]) == 0 { + t.Error("No service. Just like [insert mobile provider name here]") + } +} + +func TestLoadChart(t *testing.T) { + f, err := LoadChartfile(testfile) + if err != nil { + t.Errorf("Error loading %s: %s", testfile, err) + } + + if f.Name != "alpine-pod" { + t.Errorf("Expected alpine-pod, got %s", f.Name) + } + + if len(f.Maintainers) != 2 { + t.Errorf("Expected 2 maintainers, got %d", len(f.Maintainers)) + } + + if len(f.Dependencies) != 2 { + t.Errorf("Expected 2 dependencies, got %d", len(f.Dependencies)) + } + + if f.Dependencies[1].Name != "bar" { + t.Errorf("Expected second dependency to be bar: %q", f.Dependencies[1].Name) + } + + if f.PreInstall["mykeys"] != "generate-keypair foo" { + t.Errorf("Expected map value for mykeys.") + } + + if f.Source[0] != "https://example.com/helm" { + t.Errorf("Expected https://example.com/helm, got %s", f.Source) + } +} + +func TestVersionOK(t *testing.T) { + f, err := LoadChartfile(testfile) + if err != nil { + t.Errorf("Error loading %s: %s", testfile, err) + } + + // These are canaries. The SemVer package exhuastively tests the + // various permutations. This will alert us if we wired it up + // incorrectly. + + d := f.Dependencies[1] + if d.VersionOK("1.0.0") { + t.Errorf("1.0.0 should have been marked out of range") + } + + if !d.VersionOK("1.2.3") { + t.Errorf("Version 1.2.3 should have been marked in-range") + } + +} + +func TestUnknownKinds(t *testing.T) { + known := []string{"Pod"} + c, err := Load(testchart) + if err != nil { + t.Errorf("Failed to load chart: %s", err) + } + + unknown := c.UnknownKinds(known) + if len(unknown) < 5 { + t.Errorf("Expected at least 5 unknown chart types, got %d.", len(unknown)) + } + + for _, k := range unknown { + if k == "Pod" { + t.Errorf("Pod is not an unknown kind.") + } + } +} diff --git a/chart/chartfile.go b/chart/chartfile.go new file mode 100644 index 000000000..821f941be --- /dev/null +++ b/chart/chartfile.go @@ -0,0 +1,79 @@ +package chart + +import ( + "io/ioutil" + + "github.com/Masterminds/semver" + "gopkg.in/yaml.v2" +) + +// Chartfile describes a Helm Chart (e.g. Chart.yaml) +type Chartfile struct { + Name string `yaml:"name"` + Description string `yaml:"description"` + Version string `yaml:"version"` + Keywords []string `yaml:"keywords,omitempty"` + Maintainers []*Maintainer `yaml:"maintainers,omitempty"` + Source []string `yaml:"source,omitempty"` + Home string `yaml:"home"` + Dependencies []*Dependency `yaml:"dependencies,omitempty"` + Environment []*EnvConstraint `yaml:"environment,omitempty"` +} + +// Maintainer describes a chart maintainer. +type Maintainer struct { + Name string `yaml:"name"` + Email string `yaml:"email,omitempty"` +} + +// Dependency describes a specific dependency. +type Dependency struct { + Name string `yaml:"name,omitempty"` + Version string `yaml:"version"` + Location string `yaml:"location"` +} + +// Specify environmental constraints. +type EnvConstraint struct { + Name string `yaml:"name"` + Version string `yaml:"version"` + Extensions []string `yaml:"extensions,omitempty"` + APIGroups []string `yaml:"apiGroups,omitempty"` +} + +// LoadChartfile loads a Chart.yaml file into a *Chart. +func LoadChartfile(filename string) (*Chartfile, error) { + b, err := ioutil.ReadFile(filename) + if err != nil { + return nil, err + } + var y Chartfile + return &y, yaml.Unmarshal(b, &y) +} + +// Save saves a Chart.yaml file +func (c *Chartfile) Save(filename string) error { + b, err := yaml.Marshal(c) + if err != nil { + return err + } + + return ioutil.WriteFile(filename, b, 0644) +} + +// VersionOK returns true if the given version meets the constraints. +// +// It returns false if the version string or constraint is unparsable or if the +// version does not meet the constraint. +func (d *Dependency) VersionOK(version string) bool { + c, err := semver.NewConstraint(d.Version) + if err != nil { + return false + } + v, err := semver.NewVersion(version) + if err != nil { + return false + } + + return c.Check(v) +} diff --git a/chart/chartfile_test.go b/chart/chartfile_test.go new file mode 100644 index 000000000..78413fd86 --- /dev/null +++ b/chart/chartfile_test.go @@ -0,0 +1,60 @@ +package chart + +import ( + "io/ioutil" + "os" + "testing" +) + +var testChart = `#helm:generate foo +name: frobniz +description: This is a frobniz. +version: 1.2.3-alpha.1+12345 +keywords: + - frobnitz + - sprocket + - dodad +maintainers: + - name: The Helm Team + email: helm@example.com + - name: Someone Else + email: nobody@example.com +source: https://example.com/foo/bar +home: http://example.com +dependencies: + - name: thingerbob + location: https://example.com/charts/thingerbob-3.2.1.tgz + version: ^3 +environment: + - name: Kubernetes + version: ~1.1 + extensions: + - extensions/v1beta1 + - extensions/v1beta1/daemonset + apiGroups: + - 3rdParty +` + +func TestLoadChartfile(t *testing.T) { + out, err := ioutil.TempFile("", "chartfile-") + if err != nil { + t.Fatal(err) + } + tname := out.Name() + defer func() { + os.Remove(tname) + }() + + out.Write([]byte(testChart)) + out.Close() + + c, err := LoadChartfile(tname) + if err != nil { + t.Errorf("Failed to open %s: %s", tname, err) + return + } + + if len(c.Environment[0].Extensions) != 2 { + t.Errorf("Expected two extensions, got %d", len(c.Environment[0].Extensions)) + } +} diff --git a/glide.lock b/glide.lock new file mode 100644 index 000000000..2e98b0206 --- /dev/null +++ b/glide.lock @@ -0,0 +1,51 @@ +hash: db55a031aaa2f352fa5e9e4fda871039afb80e383a57fc77e4b35114d47cca8a +updated: 2016-01-26T17:30:54.243252416-07:00 +imports: +- name: github.com/emicklei/go-restful + version: b86acf97a74ed7603ac78d012f5535b4d587b156 +- name: github.com/ghodss/yaml + version: 73d445a93680fa1a78ae23a5839bad48f32ba1ee +- name: github.com/golang/glog + version: 23def4e6c14b4da8ac2ed8007337bc5eb5007998 +- name: github.com/golang/protobuf + version: 6aaa8d47701fa6cf07e914ec01fde3d4a1fe79c3 +- name: github.com/google/go-github + version: b8b4ac742977310ff6e75140a403a38dab109977 + subpackages: + - /github +- name: github.com/google/go-querystring + version: 2a60fc2ba6c19de80291203597d752e9ba58e4c0 +- name: github.com/gorilla/context + version: 1c83b3eabd45b6d76072b66b746c20815fb2872d +- name: github.com/gorilla/handlers + version: 8f2758070a82adb7a3ad6b223a0b91878f32d400 +- name: github.com/gorilla/mux + version: 26a6070f849969ba72b72256e9f14cf519751690 +- name: github.com/gorilla/schema + version: 14c555599c2a4f493c1e13fd1ea6fdf721739028 +- name: github.com/Masterminds/semver + version: c4f7ef0702f269161a60489ccbbc9f1241ad1265 +- name: github.com/mjibson/appstats + version: 0542d5f0e87ea3a8fa4174322b9532f5d04f9fa8 +- name: golang.org/x/crypto + version: 1f22c0103821b9390939b6776727195525381532 +- name: golang.org/x/net + version: 04b9de9b512f58addf28c9853d50ebef61c3953e +- name: golang.org/x/oauth2 + version: 8a57ed94ffd43444c0879fe75701732a38afc985 +- name: golang.org/x/text + version: 6d3c22c4525a4da167968fa2479be5524d2e8bd0 +- name: google.golang.com/appengine + version: "" + repo: https://google.golang.com/appengine +- name: google.golang.org/api + version: 0caa37974a5f5ae67172acf68b4970f7864f994c +- name: google.golang.org/appengine + version: 6bde959377a90acb53366051d7d587bfd7171354 +- name: google.golang.org/cloud + version: fb10e8da373d97f6ba5e648299a10b3b91f14cd5 +- name: google.golang.org/grpc + version: e29d659177655e589850ba7d3d83f7ce12ef23dd +- name: gopkg.in/yaml.v2 + version: f7716cbe52baa25d2e9b0d0da546fcf909fc16b4 +devImports: [] diff --git a/glide.yaml b/glide.yaml new file mode 100644 index 000000000..be7d7dc53 --- /dev/null +++ b/glide.yaml @@ -0,0 +1,11 @@ +package: github.com/kubernetes/deployment-manager +import: +- package: github.com/emicklei/go-restful +- package: github.com/ghodss/yaml +- package: github.com/google/go-github + subpackages: + - /github +- package: github.com/gorilla/handlers +- package: github.com/gorilla/mux +- package: gopkg.in/yaml.v2 +- package: github.com/Masterminds/semver diff --git a/log/log.go b/log/log.go new file mode 100644 index 000000000..8d74d4878 --- /dev/null +++ b/log/log.go @@ -0,0 +1,51 @@ +/* Package log provides simple convenience wrappers for logging. + +Following convention, this provides functions for logging warnings, errors, information +and debugging. +*/ +package log + +import ( + "log" + "os" +) + +// LogReceiver can receive log messages from this package. +type LogReceiver interface { + Printf(format string, v ...interface{}) +} + +// Logger is the destination for this package. +// +// The logger that this prints to. +var Logger LogReceiver = log.New(os.Stderr, "", log.LstdFlags) + +// IsDebugging controls debugging output. +// +// If this is true, debugging messages will be printed. Expensive debugging +// operations can be wrapped in `if log.IsDebugging {}`. +var IsDebugging bool = false + +// Err prints an error of severity ERROR to the log. +func Err(msg string, v ...interface{}) { + Logger.Printf("[ERROR] "+msg+"\n", v...) +} + +// Warn prints an error severity WARN to the log. +func Warn(msg string, v ...interface{}) { + Logger.Printf("[WARN] "+msg+"\n", v...) +} + +// Info prints an error of severity INFO to the log. +func Info(msg string, v ...interface{}) { + Logger.Printf("[INFO] "+msg+"\n", v...) +} + +// Debug prints an error severity DEBUG to the log. +// +// Debug will only print if IsDebugging is true. +func Debug(msg string, v ...interface{}) { + if IsDebugging { + Logger.Printf("[DEBUG] "+msg+"\n", v...) + } +} diff --git a/log/log_test.go b/log/log_test.go new file mode 100644 index 000000000..3a10b8d2a --- /dev/null +++ b/log/log_test.go @@ -0,0 +1,49 @@ +package log + +import ( + "bytes" + "fmt" + "testing" +) + +type LoggerMock struct { + b bytes.Buffer +} + +func (l *LoggerMock) Printf(m string, v ...interface{}) { + l.b.Write([]byte(fmt.Sprintf(m, v...))) +} + +func TestLogger(t *testing.T) { + l := &LoggerMock{} + Logger = l + IsDebugging = true + + Err("%s%s%s", "a", "b", "c") + expect := "[ERROR] abc\n" + if l.b.String() != expect { + t.Errorf("Expected %q, got %q", expect, l.b.String()) + } + l.b.Reset() + + tests := map[string]func(string, ...interface{}){ + "[WARN] test\n": Warn, + "[INFO] test\n": Info, + "[DEBUG] test\n": Debug, + } + + for expect, f := range tests { + f("test") + if l.b.String() != expect { + t.Errorf("Expected %q, got %q", expect, l.b.String()) + } + l.b.Reset() + } + + IsDebugging = false + Debug("HELLO") + if l.b.String() != "" { + t.Errorf("Expected debugging to disable. Got %q", l.b.String()) + } + l.b.Reset() +}