From ba7113b0754273bc6f3eeb2363a69a9253c83597 Mon Sep 17 00:00:00 2001 From: Matt Butcher Date: Fri, 16 Sep 2016 22:19:23 -0600 Subject: [PATCH] feat(helm): add 'helm dependency' commands This also refactors significant portions of the CLI, moving much of the shared code into a library. Also in this release, a testing repository server has been added. --- cmd/helm/dependency.go | 13 + cmd/helm/dependency_build.go | 85 +++++ cmd/helm/dependency_build_test.go | 115 +++++++ cmd/helm/dependency_update.go | 225 +----------- cmd/helm/dependency_update_test.go | 114 +------ cmd/helm/downloader/chart_downloader.go | 193 +++++++++++ cmd/helm/downloader/chart_downloader_test.go | 149 ++++++++ cmd/helm/downloader/doc.go | 23 ++ cmd/helm/downloader/manager.go | 323 ++++++++++++++++++ .../downloader/testdata/helm-test-key.pub | Bin 0 -> 1243 bytes .../downloader/testdata/helm-test-key.secret | Bin 0 -> 2545 bytes .../cache/kubernetes-charts-index.yaml | 38 +++ .../repository/cache/local-index.yaml | 1 + .../helmhome/repository/local/index.yaml | 0 .../helmhome/repository/repositories.yaml | 1 + .../downloader/testdata/signtest-0.1.0.tgz | Bin 0 -> 471 bytes .../testdata/signtest-0.1.0.tgz.prov | 20 ++ .../downloader/testdata/signtest/.helmignore | 5 + .../downloader/testdata/signtest/Chart.yaml | 3 + .../testdata/signtest/alpine/Chart.yaml | 6 + .../testdata/signtest/alpine/README.md | 9 + .../signtest/alpine/templates/alpine-pod.yaml | 16 + .../testdata/signtest/alpine/values.yaml | 2 + .../testdata/signtest/templates/pod.yaml | 10 + .../downloader/testdata/signtest/values.yaml | 0 cmd/helm/fetch.go | 187 +++------- cmd/helm/fetch_test.go | 128 +++++-- cmd/helm/helmpath/helmhome.go | 61 ++++ cmd/helm/helmpath/helmhome_test.go | 36 ++ cmd/helm/install.go | 16 +- cmd/helm/resolver/resolver.go | 5 +- cmd/helm/verify.go | 5 +- pkg/chartutil/expand.go | 10 + pkg/chartutil/requirements.go | 32 +- pkg/repo/index.go | 2 +- pkg/repo/repotest/doc.go | 20 ++ pkg/repo/repotest/server.go | 130 +++++++ pkg/repo/repotest/server_test.go | 107 ++++++ .../repotest/testdata/examplechart-0.1.0.tgz | Bin 0 -> 558 bytes .../testdata/examplechart/.helmignore | 21 ++ .../repotest/testdata/examplechart/Chart.yaml | 3 + .../testdata/examplechart/values.yaml | 4 + 42 files changed, 1617 insertions(+), 501 deletions(-) create mode 100644 cmd/helm/dependency_build.go create mode 100644 cmd/helm/dependency_build_test.go create mode 100644 cmd/helm/downloader/chart_downloader.go create mode 100644 cmd/helm/downloader/chart_downloader_test.go create mode 100644 cmd/helm/downloader/doc.go create mode 100644 cmd/helm/downloader/manager.go create mode 100644 cmd/helm/downloader/testdata/helm-test-key.pub create mode 100644 cmd/helm/downloader/testdata/helm-test-key.secret create mode 100644 cmd/helm/downloader/testdata/helmhome/repository/cache/kubernetes-charts-index.yaml create mode 120000 cmd/helm/downloader/testdata/helmhome/repository/cache/local-index.yaml create mode 100644 cmd/helm/downloader/testdata/helmhome/repository/local/index.yaml create mode 100644 cmd/helm/downloader/testdata/helmhome/repository/repositories.yaml create mode 100644 cmd/helm/downloader/testdata/signtest-0.1.0.tgz create mode 100755 cmd/helm/downloader/testdata/signtest-0.1.0.tgz.prov create mode 100644 cmd/helm/downloader/testdata/signtest/.helmignore create mode 100755 cmd/helm/downloader/testdata/signtest/Chart.yaml create mode 100755 cmd/helm/downloader/testdata/signtest/alpine/Chart.yaml create mode 100755 cmd/helm/downloader/testdata/signtest/alpine/README.md create mode 100755 cmd/helm/downloader/testdata/signtest/alpine/templates/alpine-pod.yaml create mode 100755 cmd/helm/downloader/testdata/signtest/alpine/values.yaml create mode 100644 cmd/helm/downloader/testdata/signtest/templates/pod.yaml create mode 100644 cmd/helm/downloader/testdata/signtest/values.yaml create mode 100644 cmd/helm/helmpath/helmhome.go create mode 100644 cmd/helm/helmpath/helmhome_test.go create mode 100644 pkg/repo/repotest/doc.go create mode 100644 pkg/repo/repotest/server.go create mode 100644 pkg/repo/repotest/server_test.go create mode 100644 pkg/repo/repotest/testdata/examplechart-0.1.0.tgz create mode 100644 pkg/repo/repotest/testdata/examplechart/.helmignore create mode 100755 pkg/repo/repotest/testdata/examplechart/Chart.yaml create mode 100644 pkg/repo/repotest/testdata/examplechart/values.yaml diff --git a/cmd/helm/dependency.go b/cmd/helm/dependency.go index 2da344052..38021613e 100644 --- a/cmd/helm/dependency.go +++ b/cmd/helm/dependency.go @@ -27,6 +27,11 @@ import ( "k8s.io/helm/pkg/chartutil" ) +const ( + reqLock = "requirements.lock" + reqYaml = "requirements.yaml" +) + const dependencyDesc = ` Manage the dependencies of a chart. @@ -82,6 +87,7 @@ func newDependencyCmd(out io.Writer) *cobra.Command { cmd.AddCommand(newDependencyListCmd(out)) cmd.AddCommand(newDependencyUpdateCmd(out)) + cmd.AddCommand(newDependencyBuildCmd(out)) return cmd } @@ -214,3 +220,10 @@ func (l *dependencyListCmd) printMissing(reqs *chartutil.Requirements, out io.Wr } } + +func lockpath(chartpath string) string { + return filepath.Join(chartpath, reqLock) +} +func reqpath(chartpath string) string { + return filepath.Join(chartpath, reqYaml) +} diff --git a/cmd/helm/dependency_build.go b/cmd/helm/dependency_build.go new file mode 100644 index 000000000..b482d5fc8 --- /dev/null +++ b/cmd/helm/dependency_build.go @@ -0,0 +1,85 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "io" + + "github.com/spf13/cobra" + + "k8s.io/helm/cmd/helm/downloader" + "k8s.io/helm/cmd/helm/helmpath" +) + +const dependencyBuildDesc = ` +Build out the charts/ directory from the requirements.lock file. + +Build is used to reconstruct a chart's dependencies to the state specified in +the lock file. This will not re-negotiate dependencies, as 'helm dependency update' +does. + +If no lock file is found, 'helm dependency build' will mirror the behavior +of 'helm dependency update'. +` + +type dependencyBuildCmd struct { + out io.Writer + chartpath string + verify bool + keyring string + helmhome helmpath.HelmHome +} + +func newDependencyBuildCmd(out io.Writer) *cobra.Command { + dbc := &dependencyBuildCmd{ + out: out, + } + + cmd := &cobra.Command{ + Use: "build [flags] CHART", + Short: "rebuild the charts/ directory based on the requirements.lock file", + Long: dependencyBuildDesc, + RunE: func(cmd *cobra.Command, args []string) error { + dbc.helmhome = helmpath.HelmHome(homePath()) + dbc.chartpath = "." + + if len(args) > 0 { + dbc.chartpath = args[0] + } + return dbc.run() + }, + } + + f := cmd.Flags() + f.BoolVar(&dbc.verify, "verify", false, "Verify the packages against signatures.") + f.StringVar(&dbc.keyring, "keyring", defaultKeyring(), "The keyring containing public keys.") + + return cmd +} + +func (d *dependencyBuildCmd) run() error { + man := &downloader.Manager{ + Out: d.out, + ChartPath: d.chartpath, + HelmHome: helmpath.HelmHome(d.helmhome), + Keyring: d.keyring, + } + if d.verify { + man.Verify = downloader.VerifyIfPossible + } + + return man.Build() +} diff --git a/cmd/helm/dependency_build_test.go b/cmd/helm/dependency_build_test.go new file mode 100644 index 000000000..6c057f83b --- /dev/null +++ b/cmd/helm/dependency_build_test.go @@ -0,0 +1,115 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package main + +import ( + "bytes" + "os" + "path/filepath" + "strings" + "testing" + + "k8s.io/helm/cmd/helm/helmpath" + "k8s.io/helm/pkg/provenance" + "k8s.io/helm/pkg/repo" + "k8s.io/helm/pkg/repo/repotest" +) + +func TestDependencyBuildCmd(t *testing.T) { + oldhome := helmHome + hh, err := tempHelmHome() + if err != nil { + t.Fatal(err) + } + helmHome = hh + defer func() { + os.RemoveAll(hh) + helmHome = oldhome + }() + + srv := repotest.NewServer(hh) + defer srv.Stop() + _, err = srv.CopyCharts("testdata/testcharts/*.tgz") + if err != nil { + t.Fatal(err) + } + + chartname := "depbuild" + if err := createTestingChart(hh, chartname, srv.URL()); err != nil { + t.Fatal(err) + } + + out := bytes.NewBuffer(nil) + dbc := &dependencyBuildCmd{out: out} + dbc.helmhome = helmpath.HelmHome(hh) + dbc.chartpath = filepath.Join(hh, chartname) + + // In the first pass, we basically want the same results as an update. + if err := dbc.run(); err != nil { + output := out.String() + t.Logf("Output: %s", output) + t.Fatal(err) + } + + output := out.String() + if !strings.Contains(output, `update from the "test" chart repository`) { + t.Errorf("Repo did not get updated\n%s", output) + } + + // Make sure the actual file got downloaded. + expect := filepath.Join(hh, chartname, "charts/reqtest-0.1.0.tgz") + if _, err := os.Stat(expect); err != nil { + t.Fatal(err) + } + + // In the second pass, we want to remove the chart's request dependency, + // then see if it restores from the lock. + lockfile := filepath.Join(hh, chartname, "requirements.lock") + if _, err := os.Stat(lockfile); err != nil { + t.Fatal(err) + } + if err := os.RemoveAll(expect); err != nil { + t.Fatal(err) + } + + if err := dbc.run(); err != nil { + output := out.String() + t.Logf("Output: %s", output) + t.Fatal(err) + } + + // Now repeat the test that the dependency exists. + expect = filepath.Join(hh, chartname, "charts/reqtest-0.1.0.tgz") + if _, err := os.Stat(expect); err != nil { + t.Fatal(err) + } + + // Make sure that build is also fetching the correct version. + hash, err := provenance.DigestFile(expect) + if err != nil { + t.Fatal(err) + } + + i, err := repo.LoadIndexFile(cacheIndexFile("test")) + if err != nil { + t.Fatal(err) + } + + if h := i.Entries["reqtest-0.1.0"].Digest; h != hash { + t.Errorf("Failed hash match: expected %s, got %s", hash, h) + } + +} diff --git a/cmd/helm/dependency_update.go b/cmd/helm/dependency_update.go index 9b9eb1d12..1d687165f 100644 --- a/cmd/helm/dependency_update.go +++ b/cmd/helm/dependency_update.go @@ -16,21 +16,12 @@ limitations under the License. package main import ( - "errors" - "fmt" "io" - "io/ioutil" - "net/url" - "os" "path/filepath" - "strings" - "github.com/ghodss/yaml" "github.com/spf13/cobra" - - "k8s.io/helm/cmd/helm/resolver" - "k8s.io/helm/pkg/chartutil" - "k8s.io/helm/pkg/repo" + "k8s.io/helm/cmd/helm/downloader" + "k8s.io/helm/cmd/helm/helmpath" ) const dependencyUpDesc = ` @@ -38,15 +29,16 @@ Update the on-disk dependencies to mirror the requirements.yaml file. This command verifies that the required charts, as expressed in 'requirements.yaml', are present in 'charts/' and are at an acceptable version. + +On successful update, this will generate a lock file that can be used to +rebuild the requirements to an exact version. ` // dependencyUpdateCmd describes a 'helm dependency update' type dependencyUpdateCmd struct { out io.Writer chartpath string - repoFile string - repopath string - helmhome string + helmhome helmpath.HelmHome verify bool keyring string } @@ -74,16 +66,14 @@ func newDependencyUpdateCmd(out io.Writer) *cobra.Command { return err } - duc.helmhome = homePath() - duc.repoFile = repositoriesFile() - duc.repopath = repositoryDirectory() + duc.helmhome = helmpath.HelmHome(homePath()) return duc.run() }, } f := cmd.Flags() - f.BoolVar(&duc.verify, "verify", false, "Verify the package against its signature.") + f.BoolVar(&duc.verify, "verify", false, "Verify the packages against signatures.") f.StringVar(&duc.keyring, "keyring", defaultKeyring(), "The keyring containing public keys.") return cmd @@ -91,197 +81,14 @@ func newDependencyUpdateCmd(out io.Writer) *cobra.Command { // run runs the full dependency update process. func (d *dependencyUpdateCmd) run() error { - if fi, err := os.Stat(d.chartpath); err != nil { - return fmt.Errorf("could not find %s: %s", d.chartpath, err) - } else if !fi.IsDir() { - return errors.New("only unpacked charts can be updated") - } - c, err := chartutil.LoadDir(d.chartpath) - if err != nil { - return err - } - - req, err := chartutil.LoadRequirements(c) - if err != nil { - if err == chartutil.ErrRequirementsNotFound { - fmt.Fprintf(d.out, "No requirements found in %s/charts.\n", d.chartpath) - return nil - } - return err - } - - // For each repo in the file, update the cached copy of that repo - if _, err := d.updateRepos(req.Dependencies); err != nil { - return err - } - - // Now we need to find out which version of a chart best satisfies the - // requirements the requirements.yaml - lock, err := d.resolve(req) - if err != nil { - return err - } - - // Now we need to fetch every package here into charts/ - if err := d.downloadAll(lock.Dependencies); err != nil { - return err - } - - // Finally, we need to write the lockfile. - return writeLock(d.chartpath, lock) -} - -// resolve takes a list of requirements and translates them into an exact version to download. -// -// This returns a lock file, which has all of the requirements normalized to a specific version. -func (d *dependencyUpdateCmd) resolve(req *chartutil.Requirements) (*chartutil.RequirementsLock, error) { - res := resolver.New(d.chartpath, d.helmhome) - return res.Resolve(req) -} - -// downloadAll takes a list of dependencies and downloads them into charts/ -func (d *dependencyUpdateCmd) downloadAll(deps []*chartutil.Dependency) error { - repos, err := loadChartRepositories(d.repopath) - if err != nil { - return err - } - - fmt.Fprintf(d.out, "Saving %d charts\n", len(deps)) - for _, dep := range deps { - fmt.Fprintf(d.out, "Downloading %s from repo %s\n", dep.Name, dep.Repository) - - target := fmt.Sprintf("%s-%s", dep.Name, dep.Version) - churl, err := findChartURL(target, dep.Repository, repos) - if err != nil { - fmt.Fprintf(d.out, "WARNING: %s (skipped)", err) - continue - } - - dest := filepath.Join(d.chartpath, "charts", target+".tgz") - data, err := downloadChart(churl, d.verify, d.keyring) - if err != nil { - fmt.Fprintf(d.out, "WARNING: Could not download %s: %s (skipped)", churl, err) - continue - } - if err := ioutil.WriteFile(dest, data.Bytes(), 0655); err != nil { - fmt.Fprintf(d.out, "WARNING: %s (skipped)", err) - continue - } - } - return nil -} - -// updateRepos updates all of the local repos to their latest. -// -// If one of the dependencies present is not in the cached repos, this will error out. The -// consequence of that is that every repository referenced in a requirements.yaml file -// must also be added with 'helm repo add'. -func (d *dependencyUpdateCmd) updateRepos(deps []*chartutil.Dependency) (*repo.RepoFile, error) { - // TODO: In the future, we could make it so that only the repositories that - // are used by this chart are updated. As it is, we're mainly doing some sanity - // checking here. - rf, err := repo.LoadRepositoriesFile(d.repoFile) - if err != nil { - return rf, err + man := &downloader.Manager{ + Out: d.out, + ChartPath: d.chartpath, + HelmHome: d.helmhome, + Keyring: d.keyring, } - repos := rf.Repositories - - // Verify that all repositories referenced in the deps are actually known - // by Helm. - missing := []string{} - for _, dd := range deps { - found := false - if dd.Repository == "" { - found = true - } else { - for _, repo := range repos { - if urlsAreEqual(repo, dd.Repository) { - found = true - } - } - } - if !found { - missing = append(missing, dd.Repository) - } - } - - if len(missing) > 0 { - return rf, fmt.Errorf("no repository definition for %s. Try 'helm repo add'", strings.Join(missing, ", ")) - } - - if len(repos) > 0 { - // This prints errors straight to out. - updateCharts(repos, flagDebug, d.out) - } - return rf, nil -} - -// urlsAreEqual normalizes two URLs and then compares for equality. -func urlsAreEqual(a, b string) bool { - au, err := url.Parse(a) - if err != nil { - return a == b - } - bu, err := url.Parse(b) - if err != nil { - return false - } - return au.String() == bu.String() -} - -// findChartURL searches the cache of repo data for a chart that has the name and the repourl specified. -// -// In this current version, name is of the form 'foo-1.2.3'. This will change when -// the repository index stucture changes. -func findChartURL(name, repourl string, repos map[string]*repo.ChartRepository) (string, error) { - for _, cr := range repos { - if urlsAreEqual(repourl, cr.URL) { - for ename, entry := range cr.IndexFile.Entries { - if ename == name { - return entry.URL, nil - } - } - } - } - return "", fmt.Errorf("chart %s not found in %s", name, repourl) -} - -// loadChartRepositories reads the repositories.yaml, and then builds a map of -// ChartRepositories. -// -// The key is the local name (which is only present in the repositories.yaml). -func loadChartRepositories(repodir string) (map[string]*repo.ChartRepository, error) { - indices := map[string]*repo.ChartRepository{} - repoyaml := repositoriesFile() - - // Load repositories.yaml file - rf, err := repo.LoadRepositoriesFile(repoyaml) - if err != nil { - return indices, fmt.Errorf("failed to load %s: %s", repoyaml, err) - } - - // localName: chartRepo - for lname, url := range rf.Repositories { - index, err := repo.LoadIndexFile(cacheIndexFile(lname)) - if err != nil { - return indices, err - } - - cr := &repo.ChartRepository{ - URL: url, - IndexFile: index, - } - indices[lname] = cr - } - return indices, nil -} - -// writeLock writes a lockfile to disk -func writeLock(chartpath string, lock *chartutil.RequirementsLock) error { - data, err := yaml.Marshal(lock) - if err != nil { - return err + if d.verify { + man.Verify = downloader.VerifyIfPossible } - dest := filepath.Join(chartpath, "requirements.lock") - return ioutil.WriteFile(dest, data, 0755) + return man.Update() } diff --git a/cmd/helm/dependency_update_test.go b/cmd/helm/dependency_update_test.go index b38b90a21..706983ea9 100644 --- a/cmd/helm/dependency_update_test.go +++ b/cmd/helm/dependency_update_test.go @@ -18,8 +18,6 @@ package main import ( "bytes" "io/ioutil" - "net/http" - "net/http/httptest" "os" "path/filepath" "strings" @@ -27,10 +25,12 @@ import ( "github.com/ghodss/yaml" + "k8s.io/helm/cmd/helm/helmpath" "k8s.io/helm/pkg/chartutil" "k8s.io/helm/pkg/proto/hapi/chart" "k8s.io/helm/pkg/provenance" "k8s.io/helm/pkg/repo" + "k8s.io/helm/pkg/repo/repotest" ) func TestDependencyUpdateCmd(t *testing.T) { @@ -40,36 +40,35 @@ func TestDependencyUpdateCmd(t *testing.T) { if err != nil { t.Fatal(err) } - helmHome = hh // Shoot me now. + helmHome = hh defer func() { os.RemoveAll(hh) helmHome = oldhome }() - srv := newTestingRepositoryServer(hh) - defer srv.stop() - copied, err := srv.copyCharts("testdata/testcharts/*.tgz") - t.Logf("Copied charts %s", strings.Join(copied, "\n")) - t.Logf("Listening for directory %s", srv.docroot) + srv := repotest.NewServer(hh) + defer srv.Stop() + copied, err := srv.CopyCharts("testdata/testcharts/*.tgz") + t.Logf("Copied charts:\n%s", strings.Join(copied, "\n")) + t.Logf("Listening on directory %s", srv.Root()) chartname := "depup" - if err := createTestingChart(hh, chartname, srv.url()); err != nil { + if err := createTestingChart(hh, chartname, srv.URL()); err != nil { t.Fatal(err) } out := bytes.NewBuffer(nil) duc := &dependencyUpdateCmd{out: out} - duc.helmhome = hh + duc.helmhome = helmpath.HelmHome(hh) duc.chartpath = filepath.Join(hh, chartname) - duc.repoFile = filepath.Join(duc.helmhome, "repository/repositories.yaml") - duc.repopath = filepath.Join(duc.helmhome, "repository") if err := duc.run(); err != nil { + output := out.String() + t.Logf("Output: %s", output) t.Fatal(err) } output := out.String() - t.Logf("Output: %s", output) // This is written directly to stdout, so we have to capture as is. if !strings.Contains(output, `update from the "test" chart repository`) { t.Errorf("Repo did not get updated\n%s", output) @@ -98,95 +97,6 @@ func TestDependencyUpdateCmd(t *testing.T) { t.Logf("Results: %s", out.String()) } -// newTestingRepositoryServer creates a repository server for testing. -// -// docroot should be a temp dir managed by the caller. -// -// This will start the server, serving files off of the docroot. -// -// Use copyCharts to move charts into the repository and then index them -// for service. -func newTestingRepositoryServer(docroot string) *testingRepositoryServer { - root, err := filepath.Abs(docroot) - if err != nil { - panic(err) - } - srv := &testingRepositoryServer{ - docroot: root, - } - srv.start() - // Add the testing repository as the only repo. - if err := setTestingRepository(docroot, "test", srv.url()); err != nil { - panic(err) - } - return srv -} - -type testingRepositoryServer struct { - docroot string - srv *httptest.Server -} - -// copyCharts takes a glob expression and copies those charts to the server root. -func (s *testingRepositoryServer) copyCharts(origin string) ([]string, error) { - files, err := filepath.Glob(origin) - if err != nil { - return []string{}, err - } - copied := make([]string, len(files)) - for i, f := range files { - base := filepath.Base(f) - newname := filepath.Join(s.docroot, base) - data, err := ioutil.ReadFile(f) - if err != nil { - return []string{}, err - } - if err := ioutil.WriteFile(newname, data, 0755); err != nil { - return []string{}, err - } - copied[i] = newname - } - - // generate the index - index, err := repo.IndexDirectory(s.docroot, s.url()) - if err != nil { - return copied, err - } - - d, err := yaml.Marshal(index.Entries) - if err != nil { - return copied, err - } - - ifile := filepath.Join(s.docroot, "index.yaml") - err = ioutil.WriteFile(ifile, d, 0755) - return copied, err -} - -func (s *testingRepositoryServer) start() { - s.srv = httptest.NewServer(http.FileServer(http.Dir(s.docroot))) -} - -func (s *testingRepositoryServer) stop() { - s.srv.Close() -} - -func (s *testingRepositoryServer) url() string { - return s.srv.URL -} - -// setTestingRepository sets up a testing repository.yaml with only the given name/URL. -func setTestingRepository(helmhome, name, url string) error { - // Oddly, there is no repo.Save function for this. - data, err := yaml.Marshal(&map[string]string{name: url}) - if err != nil { - return err - } - os.MkdirAll(filepath.Join(helmhome, "repository", name), 0755) - dest := filepath.Join(helmhome, "repository/repositories.yaml") - return ioutil.WriteFile(dest, data, 0666) -} - // createTestingChart creates a basic chart that depends on reqtest-0.1.0 // // The baseURL can be used to point to a particular repository server. diff --git a/cmd/helm/downloader/chart_downloader.go b/cmd/helm/downloader/chart_downloader.go new file mode 100644 index 000000000..fad20a675 --- /dev/null +++ b/cmd/helm/downloader/chart_downloader.go @@ -0,0 +1,193 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package downloader + +import ( + "bytes" + "errors" + "fmt" + "io" + "io/ioutil" + "net/http" + "net/url" + "os" + "path/filepath" + "strings" + + "k8s.io/helm/cmd/helm/helmpath" + "k8s.io/helm/pkg/provenance" + "k8s.io/helm/pkg/repo" +) + +// VerificationStrategy describes a strategy for determining whether to verify a chart. +type VerificationStrategy int + +const ( + // VerifyNever will skip all verification of a chart. + VerifyNever VerificationStrategy = iota + // VerifyIfPossible will attempt a verification, but will not stop processing + // if verification fails. + VerifyIfPossible + // VerifyAlways will always attempt a verification, and will fail if the + // verification fails. + VerifyAlways +) + +// ChartDownloader handles downloading a chart. +// +// It is capable of performing verifications on charts as well. +type ChartDownloader struct { + // Out is the location to write warning and info messages. + Out io.Writer + // Verify indicates what verification strategy to use. + Verify VerificationStrategy + // Keyring is the keyring file used for verification. + Keyring string + // HelmHome is the $HELM_HOME. + HelmHome helmpath.HelmHome +} + +// DownloadTo retrieves a chart. Depending on the settings, it may also download a provenance file. +// +// If Verify is set to VerifyNever, the verification will be nil. +// If Verify is set to VerifyIfPossible, this will return a verification (or nil on failure), and print a warning on failure. +// If Verify is set to VerifyAlways, this will return a verification or an error if the verification fails. +func (c *ChartDownloader) DownloadTo(ref string, dest string) (*provenance.Verification, error) { + // resolve URL + u, err := c.ResolveChartRef(ref) + if err != nil { + return nil, err + } + data, err := download(u.String()) + if err != nil { + return nil, err + } + + name := filepath.Base(u.Path) + destfile := filepath.Join(dest, name) + if err := ioutil.WriteFile(destfile, data.Bytes(), 0655); err != nil { + return nil, err + } + + // If provenance is requested, verify it. + var ver *provenance.Verification + if c.Verify > VerifyNever { + + body, err := download(u.String() + ".prov") + if err != nil { + if c.Verify == VerifyAlways { + return ver, fmt.Errorf("Failed to fetch provenance %q", u.String()+".prov") + } + fmt.Fprintf(c.Out, "WARNING: Verification not found for %s: %s", ref, err) + } + provfile := destfile + ".prov" + if err := ioutil.WriteFile(provfile, body.Bytes(), 0655); err != nil { + return nil, err + } + + ver, err = VerifyChart(destfile, c.Keyring) + if err != nil { + // Fail always in this case, since it means the verification step + // failed. + return ver, err + } + } + return ver, nil +} + +// ResolveChartRef resolves a chart reference to a URL. +// +// A reference may be an HTTP URL, a 'reponame/chartname' reference, or a local path. +func (c *ChartDownloader) ResolveChartRef(ref string) (*url.URL, error) { + // See if it's already a full URL. + u, err := url.ParseRequestURI(ref) + if err == nil { + // If it has a scheme and host and path, it's a full URL + if u.IsAbs() && len(u.Host) > 0 && len(u.Path) > 0 { + return u, nil + } + return u, fmt.Errorf("Invalid chart url format: %s", ref) + } + + r, err := repo.LoadRepositoriesFile(c.HelmHome.RepositoryFile()) + if err != nil { + return u, err + } + + // See if it's of the form: repo/path_to_chart + p := strings.Split(ref, "/") + if len(p) > 1 { + if baseURL, ok := r.Repositories[p[0]]; ok { + if !strings.HasSuffix(baseURL, "/") { + baseURL = baseURL + "/" + } + return url.ParseRequestURI(baseURL + strings.Join(p[1:], "/")) + } + return u, fmt.Errorf("No such repo: %s", p[0]) + } + return u, fmt.Errorf("Invalid chart url format: %s", ref) +} + +// VerifyChart takes a path to a chart archive and a keyring, and verifies the chart. +// +// It assumes that a chart archive file is accompanied by a provenance file whose +// name is the archive file name plus the ".prov" extension. +func VerifyChart(path string, keyring string) (*provenance.Verification, error) { + // For now, error out if it's not a tar file. + if fi, err := os.Stat(path); err != nil { + return nil, err + } else if fi.IsDir() { + return nil, errors.New("unpacked charts cannot be verified") + } else if !isTar(path) { + return nil, errors.New("chart must be a tgz file") + } + + provfile := path + ".prov" + if _, err := os.Stat(provfile); err != nil { + return nil, fmt.Errorf("could not load provenance file %s: %s", provfile, err) + } + + sig, err := provenance.NewFromKeyring(keyring, "") + if err != nil { + return nil, fmt.Errorf("failed to load keyring: %s", err) + } + return sig.Verify(path, provfile) +} + +// download performs a simple HTTP Get and returns the body. +func download(href string) (*bytes.Buffer, error) { + buf := bytes.NewBuffer(nil) + + resp, err := http.Get(href) + if err != nil { + return buf, err + } + if resp.StatusCode != 200 { + return buf, fmt.Errorf("Failed to fetch %s : %s", href, resp.Status) + } + + _, err = io.Copy(buf, resp.Body) + resp.Body.Close() + return buf, err +} + +// isTar tests whether the given file is a tar file. +// +// Currently, this simply checks extension, since a subsequent function will +// untar the file and validate its binary format. +func isTar(filename string) bool { + return strings.ToLower(filepath.Ext(filename)) == ".tgz" +} diff --git a/cmd/helm/downloader/chart_downloader_test.go b/cmd/helm/downloader/chart_downloader_test.go new file mode 100644 index 000000000..41bde281d --- /dev/null +++ b/cmd/helm/downloader/chart_downloader_test.go @@ -0,0 +1,149 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package downloader + +import ( + "fmt" + "io/ioutil" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "testing" + + "k8s.io/helm/cmd/helm/helmpath" + "k8s.io/helm/pkg/repo/repotest" +) + +func TestResolveChartRef(t *testing.T) { + tests := []struct { + name, ref, expect string + fail bool + }{ + {name: "full URL", ref: "http://example.com/foo-1.2.3.tgz", expect: "http://example.com/foo-1.2.3.tgz"}, + {name: "full URL, HTTPS", ref: "https://example.com/foo-1.2.3.tgz", expect: "https://example.com/foo-1.2.3.tgz"}, + {name: "reference, testing repo", ref: "testing/foo-1.2.3.tgz", expect: "http://example.com/foo-1.2.3.tgz"}, + {name: "full URL, file", ref: "file:///foo-1.2.3.tgz", fail: true}, + {name: "invalid", ref: "invalid-1.2.3", fail: true}, + {name: "not found", ref: "nosuchthing/invalid-1.2.3", fail: true}, + } + + c := ChartDownloader{ + HelmHome: helmpath.HelmHome("testdata/helmhome"), + Out: os.Stderr, + } + + for _, tt := range tests { + u, err := c.ResolveChartRef(tt.ref) + if err != nil { + if tt.fail { + continue + } + t.Errorf("%s: failed with error %s", tt.name, err) + continue + } + if got := u.String(); got != tt.expect { + t.Errorf("%s: expected %s, got %s", tt.name, tt.expect, got) + } + } +} + +func TestVerifyChart(t *testing.T) { + v, err := VerifyChart("testdata/signtest-0.1.0.tgz", "testdata/helm-test-key.pub") + if err != nil { + t.Fatal(err) + } + // The verification is tested at length in the provenance package. Here, + // we just want a quick sanity check that the v is not empty. + if len(v.FileHash) == 0 { + t.Error("Digest missing") + } +} + +func TestDownload(t *testing.T) { + expect := "Call me Ishmael" + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprint(w, expect) + })) + defer srv.Close() + + got, err := download(srv.URL) + if err != nil { + t.Fatal(err) + } + + if got.String() != expect { + t.Errorf("Expected %q, got %q", expect, got.String()) + } +} + +func TestIsTar(t *testing.T) { + tests := map[string]bool{ + "foo.tgz": true, + "foo/bar/baz.tgz": true, + "foo-1.2.3.4.5.tgz": true, + "foo.tar.gz": false, // for our purposes + "foo.tgz.1": false, + "footgz": false, + } + + for src, expect := range tests { + if isTar(src) != expect { + t.Errorf("%q should be %t", src, expect) + } + } +} + +func TestDownloadTo(t *testing.T) { + hh, err := ioutil.TempDir("", "helm-downloadto-") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(hh) + + dest := filepath.Join(hh, "dest") + os.MkdirAll(dest, 0755) + + // Set up a fake repo + srv := repotest.NewServer(hh) + defer srv.Stop() + if _, err := srv.CopyCharts("testdata/*.tgz*"); err != nil { + t.Error(err) + return + } + + c := ChartDownloader{ + HelmHome: helmpath.HelmHome("testdata/helmhome"), + Out: os.Stderr, + Verify: VerifyAlways, + Keyring: "testdata/helm-test-key.pub", + } + cname := "/signtest-0.1.0.tgz" + v, err := c.DownloadTo(srv.URL()+cname, dest) + if err != nil { + t.Error(err) + return + } + + if v.FileHash == "" { + t.Error("File hash was empty, but verification is required.") + } + + if _, err := os.Stat(filepath.Join(dest, cname)); err != nil { + t.Error(err) + return + } +} diff --git a/cmd/helm/downloader/doc.go b/cmd/helm/downloader/doc.go new file mode 100644 index 000000000..fb54936b8 --- /dev/null +++ b/cmd/helm/downloader/doc.go @@ -0,0 +1,23 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +/*Package downloader provides a library for downloading charts. + +This package contains various tools for downloading charts from repository +servers, and then storing them in Helm-specific directory structures (like +HELM_HOME). This library contains many functions that depend on a specific +filesystem layout. +*/ +package downloader diff --git a/cmd/helm/downloader/manager.go b/cmd/helm/downloader/manager.go new file mode 100644 index 000000000..4b45f15ed --- /dev/null +++ b/cmd/helm/downloader/manager.go @@ -0,0 +1,323 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package downloader + +import ( + "errors" + "fmt" + "io" + "io/ioutil" + "net/url" + "os" + "path/filepath" + "strings" + "sync" + + "github.com/ghodss/yaml" + + "k8s.io/helm/cmd/helm/helmpath" + "k8s.io/helm/cmd/helm/resolver" + "k8s.io/helm/pkg/chartutil" + "k8s.io/helm/pkg/proto/hapi/chart" + "k8s.io/helm/pkg/repo" +) + +// Manager handles the lifecycle of fetching, resolving, and storing dependencies. +type Manager struct { + // Out is used to print warnings and notifications. + Out io.Writer + // ChartPath is the path to the unpacked base chart upon which this operates. + ChartPath string + // HelmHome is the $HELM_HOME directory + HelmHome helmpath.HelmHome + // Verification indicates whether the chart should be verified. + Verify VerificationStrategy + // Keyring is the key ring file. + Keyring string +} + +// Build rebuilds a local charts directory from a lockfile. +// +// If the lockfile is not present, this will run a Manager.Update() +func (m *Manager) Build() error { + c, err := m.loadChartDir() + if err != nil { + return err + } + + // If a lock file is found, run a build from that. Otherwise, just do + // an update. + lock, err := chartutil.LoadRequirementsLock(c) + if err != nil { + return m.Update() + } + + // TODO: If the hash in the lock file doesn't match the digest of the + // actual yaml file, return an error. + + // Check that all of the repos we're dependent on actually exist. + if err := m.hasAllRepos(lock.Dependencies); err != nil { + return err + } + + // For each repo in the file, update the cached copy of that repo + if err := m.UpdateRepositories(); err != nil { + return err + } + + // Now we need to fetch every package here into charts/ + if err := m.downloadAll(lock.Dependencies); err != nil { + return err + } + + return nil +} + +// Update updates a local charts directory. +// +// It first reads the requirements.yaml file, and then attempts to +// negotiate versions based on that. It will download the versions +// from remote chart repositories. +func (m *Manager) Update() error { + c, err := m.loadChartDir() + if err != nil { + return err + } + + // If no requirements file is found, we consider this a successful + // completion. + req, err := chartutil.LoadRequirements(c) + if err != nil { + if err == chartutil.ErrRequirementsNotFound { + fmt.Fprintf(m.Out, "No requirements found in %s/charts.\n", m.ChartPath) + return nil + } + return err + } + + // Check that all of the repos we're dependent on actually exist. + if err := m.hasAllRepos(req.Dependencies); err != nil { + return err + } + + // For each repo in the file, update the cached copy of that repo + if err := m.UpdateRepositories(); err != nil { + return err + } + + // Now we need to find out which version of a chart best satisfies the + // requirements the requirements.yaml + lock, err := m.resolve(req) + if err != nil { + return err + } + + // Now we need to fetch every package here into charts/ + if err := m.downloadAll(lock.Dependencies); err != nil { + return err + } + + // Finally, we need to write the lockfile. + return writeLock(m.ChartPath, lock) +} + +func (m *Manager) loadChartDir() (*chart.Chart, error) { + if fi, err := os.Stat(m.ChartPath); err != nil { + return nil, fmt.Errorf("could not find %s: %s", m.ChartPath, err) + } else if !fi.IsDir() { + return nil, errors.New("only unpacked charts can be updated") + } + return chartutil.LoadDir(m.ChartPath) +} + +// resolve takes a list of requirements and translates them into an exact version to download. +// +// This returns a lock file, which has all of the requirements normalized to a specific version. +func (m *Manager) resolve(req *chartutil.Requirements) (*chartutil.RequirementsLock, error) { + res := resolver.New(m.ChartPath, m.HelmHome) + return res.Resolve(req) +} + +// downloadAll takes a list of dependencies and downloads them into charts/ +func (m *Manager) downloadAll(deps []*chartutil.Dependency) error { + repos, err := m.loadChartRepositories() + if err != nil { + return err + } + + dl := ChartDownloader{ + Out: m.Out, + Verify: m.Verify, + Keyring: m.Keyring, + HelmHome: m.HelmHome, + } + + fmt.Fprintf(m.Out, "Saving %d charts\n", len(deps)) + for _, dep := range deps { + fmt.Fprintf(m.Out, "Downloading %s from repo %s\n", dep.Name, dep.Repository) + + target := fmt.Sprintf("%s-%s", dep.Name, dep.Version) + churl, err := findChartURL(target, dep.Repository, repos) + if err != nil { + fmt.Fprintf(m.Out, "WARNING: %s (skipped)", err) + continue + } + + dest := filepath.Join(m.ChartPath, "charts") + if _, err := dl.DownloadTo(churl, dest); err != nil { + fmt.Fprintf(m.Out, "WARNING: Could not download %s: %s (skipped)", churl, err) + continue + } + } + return nil +} + +// hasAllRepos ensures that all of the referenced deps are in the local repo cache. +func (m *Manager) hasAllRepos(deps []*chartutil.Dependency) error { + rf, err := repo.LoadRepositoriesFile(m.HelmHome.RepositoryFile()) + if err != nil { + return err + } + repos := rf.Repositories + // Verify that all repositories referenced in the deps are actually known + // by Helm. + missing := []string{} + for _, dd := range deps { + found := false + if dd.Repository == "" { + found = true + } else { + for _, repo := range repos { + if urlsAreEqual(repo, dd.Repository) { + found = true + } + } + } + if !found { + missing = append(missing, dd.Repository) + } + } + if len(missing) > 0 { + return fmt.Errorf("no repository definition for %s. Try 'helm repo add'", strings.Join(missing, ", ")) + } + return nil +} + +// UpdateRepositories updates all of the local repos to the latest. +func (m *Manager) UpdateRepositories() error { + rf, err := repo.LoadRepositoriesFile(m.HelmHome.RepositoryFile()) + if err != nil { + return err + } + repos := rf.Repositories + if len(repos) > 0 { + // This prints warnings straight to out. + m.parallelRepoUpdate(repos) + } + return nil +} + +func (m *Manager) parallelRepoUpdate(repos map[string]string) { + out := m.Out + fmt.Fprintln(out, "Hang tight while we grab the latest from your chart repositories...") + var wg sync.WaitGroup + for name, url := range repos { + wg.Add(1) + go func(n, u string) { + err := repo.DownloadIndexFile(n, u, m.HelmHome.CacheIndex(n)) + if err != nil { + updateErr := fmt.Sprintf("...Unable to get an update from the %q chart repository: %s", n, err) + fmt.Fprintln(out, updateErr) + } else { + fmt.Fprintf(out, "...Successfully got an update from the %q chart repository\n", n) + } + wg.Done() + }(name, url) + } + wg.Wait() + fmt.Fprintln(out, "Update Complete. Happy Helming!") +} + +// urlsAreEqual normalizes two URLs and then compares for equality. +func urlsAreEqual(a, b string) bool { + au, err := url.Parse(a) + if err != nil { + return a == b + } + bu, err := url.Parse(b) + if err != nil { + return false + } + return au.String() == bu.String() +} + +// findChartURL searches the cache of repo data for a chart that has the name and the repourl specified. +// +// In this current version, name is of the form 'foo-1.2.3'. This will change when +// the repository index stucture changes. +func findChartURL(name, repourl string, repos map[string]*repo.ChartRepository) (string, error) { + for _, cr := range repos { + if urlsAreEqual(repourl, cr.URL) { + for ename, entry := range cr.IndexFile.Entries { + if ename == name { + return entry.URL, nil + } + } + } + } + return "", fmt.Errorf("chart %s not found in %s", name, repourl) +} + +// loadChartRepositories reads the repositories.yaml, and then builds a map of +// ChartRepositories. +// +// The key is the local name (which is only present in the repositories.yaml). +func (m *Manager) loadChartRepositories() (map[string]*repo.ChartRepository, error) { + indices := map[string]*repo.ChartRepository{} + repoyaml := m.HelmHome.RepositoryFile() + + // Load repositories.yaml file + rf, err := repo.LoadRepositoriesFile(repoyaml) + if err != nil { + return indices, fmt.Errorf("failed to load %s: %s", repoyaml, err) + } + + // localName: chartRepo + for lname, url := range rf.Repositories { + cacheindex := m.HelmHome.CacheIndex(lname) + index, err := repo.LoadIndexFile(cacheindex) + if err != nil { + return indices, err + } + + cr := &repo.ChartRepository{ + URL: url, + IndexFile: index, + } + indices[lname] = cr + } + return indices, nil +} + +// writeLock writes a lockfile to disk +func writeLock(chartpath string, lock *chartutil.RequirementsLock) error { + data, err := yaml.Marshal(lock) + if err != nil { + return err + } + dest := filepath.Join(chartpath, "requirements.lock") + return ioutil.WriteFile(dest, data, 0755) +} diff --git a/cmd/helm/downloader/testdata/helm-test-key.pub b/cmd/helm/downloader/testdata/helm-test-key.pub new file mode 100644 index 0000000000000000000000000000000000000000..38714f25adaf701b08e11fd559a587074bbde0e4 GIT binary patch literal 1243 zcmV<11SI>J0SyFKmTjH^2mr{k15wFPQdpTAAEclY4oV^-7nTy5x$&xF;PC4il}o-Pk4@#$knlp#(|J0GE?qli_lr;7-o zyY8vBsN_GJe;#w<`JdR7riNL&RJlcS)FG+W=91;dYS6NZ2tY?kZ8Sw9{r=e4|L3E{ zRod|EPC!PWgW&pe&4qiqKQAijj;G~fyjcC^m%0p54Tn{h%YFKd0VC4n=#~SRc@BVd znj66*)Om%*SEQfX{1*Tb0RRECT}WkYZ6H)-b98BLXCNq4XlZjGYh`&Lb7*gMY-AvB zZftoVVr3w8b7f>8W^ZyJbY*jNX>MmOAVg0fPES-IR8mz_R4yqXJZNQXZ7p6uVakV zT7GGV$jaKjyjfI_a~N1!Hk?5C$0wa&4)R=i$v7t&ZMycW#RkavpF%A?>MTT2anNDzOQUm<++zEOykJ9-@&c2QXq3owqf7fek`=L@+7iF zv;IW2Q>Q&r+V@cWDF&hAUUsCKlDinerKgvJUJCl$5gjb7NhM{mBP%!M^mX-iS8xFf zuLB{@MDqvtZzF#Bxd9CXSC(y_0SExW>8~h=U8|!do4*OJj2u#!KDe3v+1T+aVzU5di=Ji2)x37y$|Z2?YXImTjH_8w>yn2@r%kznCAv zhhp0`2mpxVj5j%o&5i)?`r7iES|8dA@p2kk@+XS(tjBGN)6>tm^=gayCn`gTEC*K74Y~{I_PREk) z)PstIMx1RxB@cK8%Mey%;nVnKriAKUk2Ky?dBMG3uXItKL$3N(#3P^pQa*K$l)wUy F^>pMLK0g2e literal 0 HcmV?d00001 diff --git a/cmd/helm/downloader/testdata/helm-test-key.secret b/cmd/helm/downloader/testdata/helm-test-key.secret new file mode 100644 index 0000000000000000000000000000000000000000..a966aef93ed97d01d764f29940738df6df2d9d24 GIT binary patch literal 2545 zcmVclY4oV^-7nTy5x$&xF;PC4il}o-Pk4@#$knlp#(|J0GE?qli_lr;7-o zyY8vBsN_GJe;#w<`JdR7riNL&RJlcS)FG+W=91;dYS6NZ2tY?kZ8Sw9{r=e4|L3E{ zRod|EPC!PWgW&pe&4qiqKQAijj;G~fyjcC^m%0p54Tn{h%YFKd0VC4n=#~SRc@BVd znj66*)Om%*SEQfX{1*Tb0RRC22mUT~!#(ymA#eaSp1lpODzX${Vf^l{qDyu}xC-Z; zRnH<54GSVm<$?Ua1k#(+mu~3_*CIx=sPuoZB#9t`5)>)SncaZ0<~%)I$~BM-5aP3W z%`ewoaI;P40uHnDeE!9-_o2Lr{wDfL45jGGU-JZ36T9ToJqMX(TnRN-EvGi{o6aI#oT_2HU(J8=theYZsj5h?ml@F2 zqCpxqkdZi=~i+&Z}q^cR< zq>lNT5cnJ5X@K!3vOww0B>@Bg*7x*i59vbegj}$ELl?K2l`+`uY;jn;@-#}^!(c8$ z&Y`@LLxZ_Y>^#gGbxsy-2s=w7cVmR@z_%b#0_e^qDmIrpKw6U7N;6^TN}@&nxKj6i zje++&m}XQA&G8O8FX86?Frxrjmu5ktfDRyHBb|j&n&H#v>T!Mdmk8Y#1OV>P(*gow;}0v-BdsmdUSV3M9tIkRO0OTBw16eYCzxs>OEG!?i}$^8yY+hFlb3GJ~F z@#2Vimrfeb0(o3X?>!tSIROL!mGC1>cHXGVp;VD$oE{N!h=IF(C(PNLd6^nZO^!ix zHnE%@Y*d~bJl_M}WW0D1EM+&xdQI5#y67>-8{P4^*?j9-RL!3>e89fC4fbJFTGXY* zQA`Z&jZ*qV!0N>p>(<2RFPDhHj^h*B*O(i139Dwv{>MY%puY021Or@)I~ufINM&qo zAXH^@bZKs9AShI5X>%ZJWqBZTXm53FWFT*DY^`Z*m}XWpi|CZf7na zL{A`2PgEdOQdLt_E-4^9Xk~0|Ep%mbbZKs9Kxk!bZ7y?YK8XQ01QP)Y03iheSC(y_ z0viJb3ke7Z0|gZd2?z@X76JnS00JHX0vCV)3JDN|JHMD8!G~grMF;@2`RLQ-(ihS@ zk(ZDi8>PUMNBttVp^;f=(#~5ORUCP*V~o^Verbou%G$oXSyYd67+6|1oIv=;C!Jsp z@?3ezI42oxy7sHZ2FUrJLM=V)2rULvozb@g^vZ~+Ui10l{t^9T2DBYydv1DFI?mTjH^2mrz9 zuPBIJtD_~GzX`6498#D*yg_W@HI~u}LQvFZ zjHz2I7O5nm<}d0gU&SbRw}dGu2{gYWzK!Qb2tL4r=Ttf(&pz_gadeY}n}E@spby2h zn?Jq8s}cOpE&?`36cTnn-abrV^*hkY1rlNa6>W(?OAePZXMfE&?IzWku7z=T;E66)b)o_po?XSOFY;U!8IY8l|z)F~<`!sdiAt3+}0RRC2 z2mUKrERA52qzq^qU4-%uqeMA@h`$YTvMnKwO3MFdg819*{h|i5{tcC;Av-jm`%7`? zISDa>*_u$~x5)kpVt_aYB_e`#K)Xd5tcJ05BQ>ps?qeo`#OS{-ilRZ+9`nljqxsy1 zp;Lu#*--$l?6qncfhI%m^w(3lOt}ywL5?%+_Ov|T=-O)O#|1&>=}51a%Sb~KTR2_K z!};{n;NgPO;;v%0;n-j>b-Y|l)x=^&d84lKmr8o*+q*$Sul50u>9%n+e!b~90-}xc znpRXgsh*hBzGXpmnXaxdFnD1FEnbiC?537`DY#mL7&iHNEY4|+!A|s9dFssoYIy_z z+imR1K+cnVPeX&M1X~ed#U~gsS6HR0zgm1NR~u@{BN;*5Gvl)42%Kq{=4gSyFIAOo zw)ZGKn^3RZn+iXfb*zL1mnJJGsvTLnDB5DF8)!;+KX&@(mJ7k5LnTlXYxI(#)c`4{ zo6I4Djv|uTRI{JJ9glvUHq0WkzV7H91OVbY6u%#c1Z-!^cIjhIC)Ek7Hx7cRvtc6M zYLV(#kP^D1#2+7pDzLBFanZFqRw>On{`4qC48A)&{zk{n0CZEKY$SfN1Rk^!_V}?Oa05R<~;U7Vou+rQZcj7^Zr@2q2}K8g2gzsQ|Y$Hp^5`riTL^4T#Q?}_!b9ge@36zaVNe`|(D|D@%b z?q#ETmMPVDW6=SC^ zp>(H_BkTP!*5u$7;(xt$0Z3AJ%*#wE`2MxJYbiqwMV z55Sy@$Oto*a)E^@IG(B#1R_APzVCxJvjDnj!`b?U+KFs4f-?w1(lA6SB!RPKJ5Wx? zlJL}niiAd-Z9pXtcm~T5R%GGR_+_Sq>RpdC-c)(PyDc zVQyr3R8em|NM&qo0PL1s>(ek4#&_LMab!0N8r#jSu)EfR!Yhji_ntJ+cZn_Q$NgS zvpkzm;N}PUn+EH+q3y3-=lpU{L>1c7h~5dUR^fjXXQ78U)Tn=deive8Xe@3wX&i_1nlSlsVp($*z=7V%F7C^xM zSQIRo!k1Q9pohcP^~Vpd=yk`P!wPC4(Fbg>l-wYAgBYs_dM=Cwr=jqDYbjbN8Xoju zz+u-*PRsk`(N#iL^pHpB#6N4v`e~pI-g=LV{4bY(@IPBd{_mkFeD*jS6?h%LKkQpn zPz*v=LN!Ei`JFc-ufYxM(D&Ln>QK!{XrwNHOrdNk`Xv}7y2Z|u@7iDHxvD(y*l_=| z0ndAbwfI5Suoo2f>;;2QN*+L~km-*EJsOZgkHDk|z~{R{vA N|NqlRq0#^l007yS;m800 literal 0 HcmV?d00001 diff --git a/cmd/helm/downloader/testdata/signtest-0.1.0.tgz.prov b/cmd/helm/downloader/testdata/signtest-0.1.0.tgz.prov new file mode 100755 index 000000000..94235399a --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest-0.1.0.tgz.prov @@ -0,0 +1,20 @@ +-----BEGIN PGP SIGNED MESSAGE----- +Hash: SHA512 + +description: A Helm chart for Kubernetes +name: signtest +version: 0.1.0 + +... +files: + signtest-0.1.0.tgz: sha256:dee72947753628425b82814516bdaa37aef49f25e8820dd2a6e15a33a007823b +-----BEGIN PGP SIGNATURE----- + +wsBcBAEBCgAQBQJXomNHCRCEO7+YH8GHYgAALywIAG1Me852Fpn1GYu8Q1GCcw4g +l2k7vOFchdDwDhdSVbkh4YyvTaIO3iE2Jtk1rxw+RIJiUr0eLO/rnIJuxZS8WKki +DR1LI9J1VD4dxN3uDETtWDWq7ScoPsRY5mJvYZXC8whrWEt/H2kfqmoA9LloRPWp +flOE0iktA4UciZOblTj6nAk3iDyjh/4HYL4a6tT0LjjKI7OTw4YyHfjHad1ywVCz +9dMUc1rPgTnl+fnRiSPSrlZIWKOt1mcQ4fVrU3nwtRUwTId2k8FtygL0G6M+Y6t0 +S6yaU7qfk9uTxkdkUF7Bf1X3ukxfe+cNBC32vf4m8LY4NkcYfSqK2fGtQsnVr6s= +=NyOM +-----END PGP SIGNATURE----- \ No newline at end of file diff --git a/cmd/helm/downloader/testdata/signtest/.helmignore b/cmd/helm/downloader/testdata/signtest/.helmignore new file mode 100644 index 000000000..435b756d8 --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest/.helmignore @@ -0,0 +1,5 @@ +# Patterns to ignore when building packages. +# This supports shell glob matching, relative path matching, and +# negation (prefixed with !). Only one pattern per line. +.DS_Store +.git diff --git a/cmd/helm/downloader/testdata/signtest/Chart.yaml b/cmd/helm/downloader/testdata/signtest/Chart.yaml new file mode 100755 index 000000000..90964b44a --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest/Chart.yaml @@ -0,0 +1,3 @@ +description: A Helm chart for Kubernetes +name: signtest +version: 0.1.0 diff --git a/cmd/helm/downloader/testdata/signtest/alpine/Chart.yaml b/cmd/helm/downloader/testdata/signtest/alpine/Chart.yaml new file mode 100755 index 000000000..6fbb27f18 --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest/alpine/Chart.yaml @@ -0,0 +1,6 @@ +description: Deploy a basic Alpine Linux pod +home: https://k8s.io/helm +name: alpine +sources: +- https://github.com/kubernetes/helm +version: 0.1.0 diff --git a/cmd/helm/downloader/testdata/signtest/alpine/README.md b/cmd/helm/downloader/testdata/signtest/alpine/README.md new file mode 100755 index 000000000..5bd595747 --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest/alpine/README.md @@ -0,0 +1,9 @@ +This example was generated using the command `helm create alpine`. + +The `templates/` directory contains a very simple pod resource with a +couple of parameters. + +The `values.yaml` file contains the default values for the +`alpine-pod.yaml` template. + +You can install this example using `helm install docs/examples/alpine`. diff --git a/cmd/helm/downloader/testdata/signtest/alpine/templates/alpine-pod.yaml b/cmd/helm/downloader/testdata/signtest/alpine/templates/alpine-pod.yaml new file mode 100755 index 000000000..08cf3c2c1 --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest/alpine/templates/alpine-pod.yaml @@ -0,0 +1,16 @@ +apiVersion: v1 +kind: Pod +metadata: + name: {{.Release.Name}}-{{.Chart.Name}} + labels: + heritage: {{.Release.Service}} + chartName: {{.Chart.Name}} + chartVersion: {{.Chart.Version | quote}} + annotations: + "helm.sh/created": "{{.Release.Time.Seconds}}" +spec: + restartPolicy: {{default "Never" .restart_policy}} + containers: + - name: waiter + image: "alpine:3.3" + command: ["/bin/sleep","9000"] diff --git a/cmd/helm/downloader/testdata/signtest/alpine/values.yaml b/cmd/helm/downloader/testdata/signtest/alpine/values.yaml new file mode 100755 index 000000000..bb6c06ae4 --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest/alpine/values.yaml @@ -0,0 +1,2 @@ +# The pod name +name: my-alpine diff --git a/cmd/helm/downloader/testdata/signtest/templates/pod.yaml b/cmd/helm/downloader/testdata/signtest/templates/pod.yaml new file mode 100644 index 000000000..9b00ccaf7 --- /dev/null +++ b/cmd/helm/downloader/testdata/signtest/templates/pod.yaml @@ -0,0 +1,10 @@ +apiVersion: v1 +kind: Pod +metadata: + name: signtest +spec: + restartPolicy: Never + containers: + - name: waiter + image: "alpine:3.3" + command: ["/bin/sleep","9000"] diff --git a/cmd/helm/downloader/testdata/signtest/values.yaml b/cmd/helm/downloader/testdata/signtest/values.yaml new file mode 100644 index 000000000..e69de29bb diff --git a/cmd/helm/fetch.go b/cmd/helm/fetch.go index e174bcdac..22e3fccc5 100644 --- a/cmd/helm/fetch.go +++ b/cmd/helm/fetch.go @@ -17,21 +17,16 @@ limitations under the License. package main import ( - "bytes" - "errors" "fmt" "io" "io/ioutil" - "net/http" - "net/url" "os" "path/filepath" - "strings" "github.com/spf13/cobra" + "k8s.io/helm/cmd/helm/downloader" + "k8s.io/helm/cmd/helm/helmpath" "k8s.io/helm/pkg/chartutil" - "k8s.io/helm/pkg/provenance" - "k8s.io/helm/pkg/repo" ) const fetchDesc = ` @@ -53,6 +48,7 @@ type fetchCmd struct { untar bool untardir string chartRef string + destdir string verify bool keyring string @@ -83,9 +79,10 @@ func newFetchCmd(out io.Writer) *cobra.Command { f := cmd.Flags() f.BoolVar(&fch.untar, "untar", false, "If set to true, will untar the chart after downloading it.") - f.StringVar(&fch.untardir, "untardir", ".", "If untar is specified, this flag specifies where to untar the chart.") + f.StringVar(&fch.untardir, "untardir", ".", "If untar is specified, this flag specifies the name of the directory into which the chart is expanded.") f.BoolVar(&fch.verify, "verify", false, "Verify the package against its signature.") f.StringVar(&fch.keyring, "keyring", defaultKeyring(), "The keyring containing public keys.") + f.StringVarP(&fch.destdir, "destination", "d", ".", "The location to write the chart. If this and tardir are specified, tardir is appended to this.") return cmd } @@ -96,162 +93,60 @@ func (f *fetchCmd) run() error { pname += ".tgz" } - return downloadAndSaveChart(pname, f.untar, f.untardir, f.verify, f.keyring) -} - -// downloadAndSaveChart fetches a chart over HTTP, and then (if verify is true) verifies it. -// -// If untar is true, it also unpacks the file into untardir. -func downloadAndSaveChart(pname string, untar bool, untardir string, verify bool, keyring string) error { - buf, err := downloadChart(pname, verify, keyring) - if err != nil { - return err + c := downloader.ChartDownloader{ + HelmHome: helmpath.HelmHome(homePath()), + Out: f.out, + Keyring: f.keyring, + Verify: downloader.VerifyNever, } - return saveChart(pname, buf, untar, untardir) -} -func downloadChart(pname string, verify bool, keyring string) (*bytes.Buffer, error) { - r, err := repo.LoadRepositoriesFile(repositoriesFile()) - if err != nil { - return bytes.NewBuffer(nil), err + if f.verify { + c.Verify = downloader.VerifyAlways } - // get download url - u, err := mapRepoArg(pname, r.Repositories) - if err != nil { - return bytes.NewBuffer(nil), err - } - - href := u.String() - buf, err := fetchChart(href) - if err != nil { - return buf, err - } - - if verify { - basename := filepath.Base(pname) - sigref := href + ".prov" - sig, err := fetchChart(sigref) + // If untar is set, we fetch to a tempdir, then untar and copy after + // verification. + dest := f.destdir + if f.untar { + var err error + dest, err = ioutil.TempDir("", "helm-") if err != nil { - return buf, fmt.Errorf("provenance data not downloaded from %s: %s", sigref, err) - } - if err := ioutil.WriteFile(basename+".prov", sig.Bytes(), 0755); err != nil { - return buf, fmt.Errorf("provenance data not saved: %s", err) - } - if err := verifyChart(basename, keyring); err != nil { - return buf, err + return fmt.Errorf("Failed to untar: %s", err) } + defer os.RemoveAll(dest) } - return buf, nil -} - -// verifyChart takes a path to a chart archive and a keyring, and verifies the chart. -// -// It assumes that a chart archive file is accompanied by a provenance file whose -// name is the archive file name plus the ".prov" extension. -func verifyChart(path string, keyring string) error { - // For now, error out if it's not a tar file. - if fi, err := os.Stat(path); err != nil { + v, err := c.DownloadTo(pname, dest) + if err != nil { return err - } else if fi.IsDir() { - return errors.New("unpacked charts cannot be verified") - } else if !isTar(path) { - return errors.New("chart must be a tgz file") } - provfile := path + ".prov" - if _, err := os.Stat(provfile); err != nil { - return fmt.Errorf("could not load provenance file %s: %s", provfile, err) + if f.verify { + fmt.Fprintf(f.out, "Verification: %v", v) } - sig, err := provenance.NewFromKeyring(keyring, "") - if err != nil { - return fmt.Errorf("failed to load keyring: %s", err) - } - ver, err := sig.Verify(path, provfile) - if flagDebug { - for name := range ver.SignedBy.Identities { - fmt.Printf("Signed by %q\n", name) + // After verification, untar the chart into the requested directory. + if f.untar { + ud := f.untardir + if !filepath.IsAbs(ud) { + ud = filepath.Join(f.destdir, ud) } + if fi, err := os.Stat(ud); err != nil { + if err := os.MkdirAll(ud, 0755); err != nil { + return fmt.Errorf("Failed to untar (mkdir): %s", err) + } + + } else if !fi.IsDir() { + return fmt.Errorf("Failed to untar: %s is not a directory", ud) + } + + from := filepath.Join(dest, filepath.Base(pname)) + return chartutil.ExpandFile(ud, from) } - return err + return nil } // defaultKeyring returns the expanded path to the default keyring. func defaultKeyring() string { return os.ExpandEnv("$HOME/.gnupg/pubring.gpg") } - -// isTar tests whether the given file is a tar file. -// -// Currently, this simply checks extension, since a subsequent function will -// untar the file and validate its binary format. -func isTar(filename string) bool { - return strings.ToLower(filepath.Ext(filename)) == ".tgz" -} - -// saveChart saves a chart locally. -func saveChart(name string, buf *bytes.Buffer, untar bool, untardir string) error { - if untar { - return chartutil.Expand(untardir, buf) - } - - p := strings.Split(name, "/") - return saveChartFile(p[len(p)-1], buf) -} - -// fetchChart retrieves a chart over HTTP. -func fetchChart(href string) (*bytes.Buffer, error) { - buf := bytes.NewBuffer(nil) - - resp, err := http.Get(href) - if err != nil { - return buf, err - } - if resp.StatusCode != 200 { - return buf, fmt.Errorf("Failed to fetch %s : %s", href, resp.Status) - } - - _, err = io.Copy(buf, resp.Body) - resp.Body.Close() - return buf, err -} - -// mapRepoArg figures out which format the argument is given, and creates a fetchable -// url from it. -func mapRepoArg(arg string, r map[string]string) (*url.URL, error) { - // See if it's already a full URL. - u, err := url.ParseRequestURI(arg) - if err == nil { - // If it has a scheme and host and path, it's a full URL - if u.IsAbs() && len(u.Host) > 0 && len(u.Path) > 0 { - return u, nil - } - return nil, fmt.Errorf("Invalid chart url format: %s", arg) - } - // See if it's of the form: repo/path_to_chart - p := strings.Split(arg, "/") - if len(p) > 1 { - if baseURL, ok := r[p[0]]; ok { - if !strings.HasSuffix(baseURL, "/") { - baseURL = baseURL + "/" - } - return url.ParseRequestURI(baseURL + strings.Join(p[1:], "/")) - } - return nil, fmt.Errorf("No such repo: %s", p[0]) - } - return nil, fmt.Errorf("Invalid chart url format: %s", arg) -} - -func saveChartFile(c string, r io.Reader) error { - // Grab the chart name that we'll use for the name of the file to download to. - out, err := os.Create(c) - if err != nil { - return err - } - defer out.Close() - - _, err = io.Copy(out, r) - return err -} diff --git a/cmd/helm/fetch_test.go b/cmd/helm/fetch_test.go index be548ee0c..3dd241a1f 100644 --- a/cmd/helm/fetch_test.go +++ b/cmd/helm/fetch_test.go @@ -17,49 +17,109 @@ limitations under the License. package main import ( - "fmt" - + "bytes" + "os" + "path/filepath" "testing" + + "k8s.io/helm/pkg/repo/repotest" ) -type testCase struct { - in string - expectedErr error - expectedOut string -} +func TestFetchCmd(t *testing.T) { + hh, err := tempHelmHome() + if err != nil { + t.Fatal(err) + } + old := homePath() + helmHome = hh + defer func() { + helmHome = old + os.RemoveAll(hh) + }() -var repos = map[string]string{ - "local": "http://localhost:8879/charts", - "someother": "http://storage.googleapis.com/mycharts", -} + // all flags will get "--home=TMDIR -d outdir" appended. + tests := []struct { + name string + chart string + flags []string + fail bool + failExpect string + expectFile string + expectDir bool + }{ + { + name: "Basic chart fetch", + chart: "test/signtest-0.1.0", + expectFile: "./signtest-0.1.0.tgz", + }, + { + name: "Fail fetching non-existent chart", + chart: "test/nosuchthing-0.1.0", + failExpect: "Failed to fetch", + fail: true, + }, + { + name: "Fetch and verify", + chart: "test/signtest-0.1.0", + flags: []string{"--verify", "--keyring", "testdata/helm-test-key.pub"}, + expectFile: "./signtest-0.1.0.tgz", + }, + { + name: "Fetch and fail verify", + chart: "test/reqtest-0.1.0", + flags: []string{"--verify", "--keyring", "testdata/helm-test-key.pub"}, + failExpect: "Failed to fetch provenance", + fail: true, + }, + { + name: "Fetch and untar", + chart: "test/signtest-0.1.0", + flags: []string{"--verify", "--keyring", "testdata/helm-test-key.pub", "--untar", "--untardir", "signtest"}, + expectFile: "./signtest", + expectDir: true, + }, + { + name: "Fetch, verify, untar", + chart: "test/signtest-0.1.0", + flags: []string{"--verify", "--keyring", "testdata/helm-test-key.pub", "--untar", "--untardir", "signtest"}, + expectFile: "./signtest", + expectDir: true, + }, + } -var testCases = []testCase{ - {"bad", fmt.Errorf("Invalid chart url format: bad"), ""}, - {"http://", fmt.Errorf("Invalid chart url format: http://"), ""}, - {"http://example.com", fmt.Errorf("Invalid chart url format: http://example.com"), ""}, - {"http://example.com/foo/bar", nil, "http://example.com/foo/bar"}, - {"local/nginx-2.0.0.tgz", nil, "http://localhost:8879/charts/nginx-2.0.0.tgz"}, - {"nonexistentrepo/nginx-2.0.0.tgz", fmt.Errorf("No such repo: nonexistentrepo"), ""}, -} + srv := repotest.NewServer(hh) + defer srv.Stop() -func testRunner(t *testing.T, tc testCase) { - u, err := mapRepoArg(tc.in, repos) - if (tc.expectedErr == nil && err != nil) || - (tc.expectedErr != nil && err == nil) || - (tc.expectedErr != nil && err != nil && tc.expectedErr.Error() != err.Error()) { - t.Errorf("Expected mapRepoArg to fail with input %s %v but got %v", tc.in, tc.expectedErr, err) + if _, err := srv.CopyCharts("testdata/testcharts/*.tgz*"); err != nil { + t.Fatal(err) } - if (u == nil && len(tc.expectedOut) != 0) || - (u != nil && len(tc.expectedOut) == 0) || - (u != nil && tc.expectedOut != u.String()) { - t.Errorf("Expected %s to map to fetch url %v but got %v", tc.in, tc.expectedOut, u) - } + t.Logf("HELM_HOME=%s", homePath()) -} + for _, tt := range tests { + outdir := filepath.Join(hh, "testout") + os.RemoveAll(outdir) + os.Mkdir(outdir, 0755) + + buf := bytes.NewBuffer(nil) + cmd := newFetchCmd(buf) + tt.flags = append(tt.flags, "-d", outdir) + cmd.ParseFlags(tt.flags) + if err := cmd.RunE(cmd, []string{tt.chart}); err != nil { + if tt.fail { + continue + } + t.Errorf("%q reported error: %s", tt.name, err) + continue + } -func TestMappings(t *testing.T) { - for _, tc := range testCases { - testRunner(t, tc) + ef := filepath.Join(outdir, tt.expectFile) + fi, err := os.Stat(ef) + if err != nil { + t.Errorf("%q: expected a file at %s. %s", tt.name, ef, err) + } + if fi.IsDir() != tt.expectDir { + t.Errorf("%q: expected directory=%t, but it's not.", tt.name, tt.expectDir) + } } } diff --git a/cmd/helm/helmpath/helmhome.go b/cmd/helm/helmpath/helmhome.go new file mode 100644 index 000000000..4751fb844 --- /dev/null +++ b/cmd/helm/helmpath/helmhome.go @@ -0,0 +1,61 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package helmpath + +import ( + "fmt" + "path/filepath" +) + +// HelmHome describes the location of a CLI configuration. +// +// This helper builds paths relative to a Helm Home directory. +type HelmHome string + +// String returns HelmHome as a string. +// +// Implements fmt.Stringer. +func (h HelmHome) String() string { + return string(h) +} + +// Repository returns the path to the local repository. +func (h HelmHome) Repository() string { + return filepath.Join(string(h), "repository") +} + +// RepositoryFile returns the path to the repositories.yaml file. +func (h HelmHome) RepositoryFile() string { + return filepath.Join(string(h), "repository/repositories.yaml") +} + +// Cache returns the path to the local cache. +func (h HelmHome) Cache() string { + return filepath.Join(string(h), "repository/cache") +} + +// CacheIndex returns the path to an index for the given named repository. +func (h HelmHome) CacheIndex(name string) string { + target := fmt.Sprintf("repository/cache/%s-index.yaml", name) + return filepath.Join(string(h), target) +} + +// LocalRepository returns the location to the local repo. +// +// The local repo is the one used by 'helm serve' +func (h HelmHome) LocalRepository() string { + return filepath.Join(string(h), "repository/local") +} diff --git a/cmd/helm/helmpath/helmhome_test.go b/cmd/helm/helmpath/helmhome_test.go new file mode 100644 index 000000000..3bfb176dd --- /dev/null +++ b/cmd/helm/helmpath/helmhome_test.go @@ -0,0 +1,36 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package helmpath + +import ( + "testing" +) + +func TestHelmHome(t *testing.T) { + hh := HelmHome("/r") + isEq := func(t *testing.T, a, b string) { + if a != b { + t.Errorf("Expected %q, got %q", a, b) + } + } + + isEq(t, hh.String(), "/r") + isEq(t, hh.Repository(), "/r/repository") + isEq(t, hh.RepositoryFile(), "/r/repository/repositories.yaml") + isEq(t, hh.LocalRepository(), "/r/repository/local") + isEq(t, hh.Cache(), "/r/repository/cache") + isEq(t, hh.CacheIndex("t"), "/r/repository/cache/t-index.yaml") +} diff --git a/cmd/helm/install.go b/cmd/helm/install.go index 3fab2c7fd..623f486d9 100644 --- a/cmd/helm/install.go +++ b/cmd/helm/install.go @@ -32,6 +32,8 @@ import ( "github.com/ghodss/yaml" "github.com/spf13/cobra" + "k8s.io/helm/cmd/helm/downloader" + "k8s.io/helm/cmd/helm/helmpath" "k8s.io/helm/pkg/helm" "k8s.io/helm/pkg/proto/hapi/release" "k8s.io/helm/pkg/timeconv" @@ -286,7 +288,7 @@ func locateChartPath(name string, verify bool, keyring string) (string, error) { if fi.IsDir() { return "", errors.New("cannot verify a directory") } - if err := verifyChart(abs, keyring); err != nil { + if _, err := downloader.VerifyChart(abs, keyring); err != nil { return "", err } } @@ -306,7 +308,17 @@ func locateChartPath(name string, verify bool, keyring string) (string, error) { if filepath.Ext(name) != ".tgz" { name += ".tgz" } - if err := downloadAndSaveChart(name, false, ".", verify, keyring); err == nil { + + dl := downloader.ChartDownloader{ + HelmHome: helmpath.HelmHome(homePath()), + Out: os.Stdout, + Keyring: keyring, + } + if verify { + dl.Verify = downloader.VerifyAlways + } + + if _, err := dl.DownloadTo(name, "."); err == nil { lname, err := filepath.Abs(filepath.Base(name)) if err != nil { return lname, err diff --git a/cmd/helm/resolver/resolver.go b/cmd/helm/resolver/resolver.go index 34854b538..1a727685a 100644 --- a/cmd/helm/resolver/resolver.go +++ b/cmd/helm/resolver/resolver.go @@ -23,6 +23,7 @@ import ( "github.com/Masterminds/semver" + "k8s.io/helm/cmd/helm/helmpath" "k8s.io/helm/pkg/chartutil" "k8s.io/helm/pkg/provenance" ) @@ -30,11 +31,11 @@ import ( // Resolver resolves dependencies from semantic version ranges to a particular version. type Resolver struct { chartpath string - helmhome string + helmhome helmpath.HelmHome } // New creates a new resolver for a given chart and a given helm home. -func New(chartpath string, helmhome string) *Resolver { +func New(chartpath string, helmhome helmpath.HelmHome) *Resolver { return &Resolver{ chartpath: chartpath, helmhome: helmhome, diff --git a/cmd/helm/verify.go b/cmd/helm/verify.go index 4e342daaf..07e1c9b77 100644 --- a/cmd/helm/verify.go +++ b/cmd/helm/verify.go @@ -20,6 +20,8 @@ import ( "io" "github.com/spf13/cobra" + + "k8s.io/helm/cmd/helm/downloader" ) const verifyDesc = ` @@ -63,5 +65,6 @@ func newVerifyCmd(out io.Writer) *cobra.Command { } func (v *verifyCmd) run() error { - return verifyChart(v.chartfile, v.keyring) + _, err := downloader.VerifyChart(v.chartfile, v.keyring) + return err } diff --git a/pkg/chartutil/expand.go b/pkg/chartutil/expand.go index 45bb9e474..30600cb61 100644 --- a/pkg/chartutil/expand.go +++ b/pkg/chartutil/expand.go @@ -71,3 +71,13 @@ func Expand(dir string, r io.Reader) error { } return nil } + +// ExpandFile expands the src file into the dest directroy. +func ExpandFile(dest, src string) error { + h, err := os.Open(src) + if err != nil { + return err + } + defer h.Close() + return Expand(dest, h) +} diff --git a/pkg/chartutil/requirements.go b/pkg/chartutil/requirements.go index 4a452f64c..8871edbb8 100644 --- a/pkg/chartutil/requirements.go +++ b/pkg/chartutil/requirements.go @@ -24,6 +24,18 @@ import ( "k8s.io/helm/pkg/proto/hapi/chart" ) +const ( + requirementsName = "requirements.yaml" + lockfileName = "requirements.lock" +) + +var ( + // ErrRequirementsNotFound indicates that a requirements.yaml is not found. + ErrRequirementsNotFound = errors.New(requirementsName + " not found") + // ErrLockfileNotFound indicates that a requirements.lock is not found. + ErrLockfileNotFound = errors.New(lockfileName + " not found") +) + // Dependency describes a chart upon which another chart depends. // // Dependencies can be used to express developer intent, or to capture the state @@ -65,14 +77,11 @@ type RequirementsLock struct { Dependencies []*Dependency `json:"dependencies"` } -// ErrRequirementsNotFound indicates that a requirements.yaml is not found. -var ErrRequirementsNotFound = errors.New("requirements.yaml not found") - // LoadRequirements loads a requirements file from an in-memory chart. func LoadRequirements(c *chart.Chart) (*Requirements, error) { var data []byte for _, f := range c.Files { - if f.TypeUrl == "requirements.yaml" { + if f.TypeUrl == requirementsName { data = f.Value } } @@ -82,3 +91,18 @@ func LoadRequirements(c *chart.Chart) (*Requirements, error) { r := &Requirements{} return r, yaml.Unmarshal(data, r) } + +// LoadRequirementsLock loads a requirements lock file. +func LoadRequirementsLock(c *chart.Chart) (*RequirementsLock, error) { + var data []byte + for _, f := range c.Files { + if f.TypeUrl == lockfileName { + data = f.Value + } + } + if len(data) == 0 { + return nil, ErrLockfileNotFound + } + r := &RequirementsLock{} + return r, yaml.Unmarshal(data, r) +} diff --git a/pkg/repo/index.go b/pkg/repo/index.go index b7aade1dc..cc2c17aee 100644 --- a/pkg/repo/index.go +++ b/pkg/repo/index.go @@ -93,7 +93,7 @@ func IndexDirectory(dir, baseURL string) (*IndexFile, error) { return index, nil } -// DownloadIndexFile uses +// DownloadIndexFile fetches the index from a repository. func DownloadIndexFile(repoName, url, indexFilePath string) error { var indexURL string diff --git a/pkg/repo/repotest/doc.go b/pkg/repo/repotest/doc.go new file mode 100644 index 000000000..34d4bc6b0 --- /dev/null +++ b/pkg/repo/repotest/doc.go @@ -0,0 +1,20 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +/*Package repotest provides utilities for testing. + +The server provides a testing server that can be set up and torn down quickly. +*/ +package repotest diff --git a/pkg/repo/repotest/server.go b/pkg/repo/repotest/server.go new file mode 100644 index 000000000..eb737290c --- /dev/null +++ b/pkg/repo/repotest/server.go @@ -0,0 +1,130 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package repotest + +import ( + "io/ioutil" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + + "github.com/ghodss/yaml" + + "k8s.io/helm/pkg/repo" +) + +// NewServer creates a repository server for testing. +// +// docroot should be a temp dir managed by the caller. +// +// This will start the server, serving files off of the docroot. +// +// Use CopyCharts to move charts into the repository and then index them +// for service. +func NewServer(docroot string) *Server { + root, err := filepath.Abs(docroot) + if err != nil { + panic(err) + } + srv := &Server{ + docroot: root, + } + srv.start() + // Add the testing repository as the only repo. + if err := setTestingRepository(docroot, "test", srv.URL()); err != nil { + panic(err) + } + return srv +} + +// Server is an implementaiton of a repository server for testing. +type Server struct { + docroot string + srv *httptest.Server +} + +// Root gets the docroot for the server. +func (s *Server) Root() string { + return s.docroot +} + +// CopyCharts takes a glob expression and copies those charts to the server root. +func (s *Server) CopyCharts(origin string) ([]string, error) { + files, err := filepath.Glob(origin) + if err != nil { + return []string{}, err + } + copied := make([]string, len(files)) + for i, f := range files { + base := filepath.Base(f) + newname := filepath.Join(s.docroot, base) + data, err := ioutil.ReadFile(f) + if err != nil { + return []string{}, err + } + if err := ioutil.WriteFile(newname, data, 0755); err != nil { + return []string{}, err + } + copied[i] = newname + } + + // generate the index + index, err := repo.IndexDirectory(s.docroot, s.URL()) + if err != nil { + return copied, err + } + + d, err := yaml.Marshal(index.Entries) + if err != nil { + return copied, err + } + + ifile := filepath.Join(s.docroot, "index.yaml") + err = ioutil.WriteFile(ifile, d, 0755) + return copied, err +} + +func (s *Server) start() { + s.srv = httptest.NewServer(http.FileServer(http.Dir(s.docroot))) +} + +// Stop stops the server and closes all connections. +// +// It should be called explicitly. +func (s *Server) Stop() { + s.srv.Close() +} + +// URL returns the URL of the server. +// +// Example: +// http://localhost:1776 +func (s *Server) URL() string { + return s.srv.URL +} + +// setTestingRepository sets up a testing repository.yaml with only the given name/URL. +func setTestingRepository(helmhome, name, url string) error { + // Oddly, there is no repo.Save function for this. + data, err := yaml.Marshal(&map[string]string{name: url}) + if err != nil { + return err + } + os.MkdirAll(filepath.Join(helmhome, "repository", name), 0755) + dest := filepath.Join(helmhome, "repository/repositories.yaml") + return ioutil.WriteFile(dest, data, 0666) +} diff --git a/pkg/repo/repotest/server_test.go b/pkg/repo/repotest/server_test.go new file mode 100644 index 000000000..8437ed512 --- /dev/null +++ b/pkg/repo/repotest/server_test.go @@ -0,0 +1,107 @@ +/* +Copyright 2016 The Kubernetes Authors All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +package repotest + +import ( + "io/ioutil" + "net/http" + "os" + "path/filepath" + "testing" + + "gopkg.in/yaml.v2" + + "k8s.io/helm/pkg/repo" +) + +// Young'n, in these here parts, we test our tests. + +func TestServer(t *testing.T) { + docroot, err := ioutil.TempDir("", "helm-repotest-") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(docroot) + + srv := NewServer(docroot) + defer srv.Stop() + + c, err := srv.CopyCharts("testdata/*.tgz") + if err != nil { + // Some versions of Go don't correctly fire defer on Fatal. + t.Error(err) + return + } + + if len(c) != 1 { + t.Errorf("Unexpected chart count: %d", len(c)) + } + + if filepath.Base(c[0]) != "examplechart-0.1.0.tgz" { + t.Errorf("Unexpected chart: %s", c[0]) + } + + res, err := http.Get(srv.URL() + "/examplechart-0.1.0.tgz") + if err != nil { + t.Error(err) + return + } + + if res.ContentLength < 500 { + t.Errorf("Expected at least 500 bytes of data, got %d", res.ContentLength) + } + + res, err = http.Get(srv.URL() + "/index.yaml") + if err != nil { + t.Error(err) + return + } + + data, err := ioutil.ReadAll(res.Body) + res.Body.Close() + if err != nil { + t.Error(err) + return + } + + var m map[string]*repo.ChartRef + if err := yaml.Unmarshal(data, &m); err != nil { + t.Error(err) + return + } + + if l := len(m); l != 1 { + t.Errorf("Expected 1 entry, got %d", l) + return + } + + expect := "examplechart-0.1.0" + if m[expect].Name != "examplechart-0.1.0" { + t.Errorf("Unexpected chart: %s", m[expect].Name) + } + if m[expect].Chartfile.Name != "examplechart" { + t.Errorf("Unexpected chart: %s", m[expect].Chartfile.Name) + } + + res, err = http.Get(srv.URL() + "/index.yaml-nosuchthing") + if err != nil { + t.Error(err) + return + } + if res.StatusCode != 404 { + t.Errorf("Expected 404, got %d", res.StatusCode) + } +} diff --git a/pkg/repo/repotest/testdata/examplechart-0.1.0.tgz b/pkg/repo/repotest/testdata/examplechart-0.1.0.tgz new file mode 100644 index 0000000000000000000000000000000000000000..aec86c64002af0b6d3d114e15de120306ba24baa GIT binary patch literal 558 zcmV+}0@3{+iwG0|32ul0|0w_~VMtOiV@ORlOnEsqVl!4SWK%V1T2nbTPgYhoO;>Dc zVQyr3R8em|NM&qo0PL1ui_|<6#`n6P;=Ihwt7zKpS_bxRnGqBfg^>lXByG>ManmH^ z&&-Y&es)h%R%b_KL5GorJ`AU6I5|n^`8^EY^1(=KdTxEbh>`91AkU7ef;6wH^ducV zi?Y1*h5`YMzDK==6Ha2e1Y-2fiq|Gb;=d}ZU-*A9@qZG{;6p^& zs>JH}?P1%af;tG<3e^$4%?XVHY%~u!$1YD z7b|GVV=~qWpQkt;KV$V*o2Pg;(RX