// Resolve takes a chart and a location and checks whether the chart's dependencies are satisfied. // // The `installdir` is the location where installed charts are located. Typically // this is in $HELM_HOME/workspace/charts. // // This returns a list of unsatisfied dependencies (NOT an error condition). // // It returns an error only if it cannot perform the task of resolving dependencies. // Failed dependencies to not constitute an error. func Resolve(cf *chart.Chartfile, installdir string) ([]*chart.Dependency, error) { if len(cf.Dependencies) == 0 { log.Debug("No dependencies to check. :achievement-unlocked:") return []*chart.Dependency{}, nil } cache, err := dependencyCache(installdir) if err != nil { log.Debug("Failed to build dependency cache: %s", err) return []*chart.Dependency{}, err } res := []*chart.Dependency{} // TODO: This could be made more efficient. for _, check := range cf.Dependencies { resolved := false for n, chart := range cache { log.Debug("Checking if %s (%s) %s meets %s %s", chart.Name, n, chart.Version, check.Name, check.Version) if chart.Name == check.Name && check.VersionOK(chart.Version) { log.Debug("✔︎") resolved = true break } } if !resolved { log.Debug("No matches found for %s %s", check.Name, check.Version) res = append(res, check) } } return res, nil }
// Check by chart directory name whether a chart is fetched into the workspace. // // This does NOT check the Chart.yaml file. func chartFetched(chartName, home string) bool { p := helm.WorkspaceChartDirectory(home, chartName, Chartfile) log.Debug("Looking for %q", p) if fi, err := os.Stat(p); err != nil || fi.IsDir() { log.Debug("No chart: %s", err) return false } return true }
// Check by chart directory name whether a chart is fetched into the workspace. // // This does NOT check the Chart.yaml file. func chartFetched(chartName, home string) bool { p := filepath.Join(home, WorkspaceChartPath, chartName, "Chart.yaml") log.Debug("Looking for %q", p) if fi, err := os.Stat(p); err != nil || fi.IsDir() { log.Debug("No chart: %s", err) return false } return true }
func fetch(chartName, lname, homedir, chartpath string) { src := helm.CacheDirectory(homedir, chartpath, chartName) dest := helm.WorkspaceChartDirectory(homedir, lname) fi, err := os.Stat(src) if err != nil { log.Warn("Oops. Looks like there was an issue finding the chart, %s, n %s. Running `helm update` to ensure you have the latest version of all Charts from Github...", lname, src) Update(homedir) fi, err = os.Stat(src) if err != nil { log.Die("Chart %s not found in %s", lname, src) } log.Info("Good news! Looks like that did the trick. Onwards and upwards!") } if !fi.IsDir() { log.Die("Malformed chart %s: Chart must be in a directory.", chartName) } if err := os.MkdirAll(dest, 0755); err != nil { log.Die("Could not create %q: %s", dest, err) } log.Debug("Fetching %s to %s", src, dest) if err := helm.CopyDir(src, dest); err != nil { log.Die("Failed copying %s to %s", src, dest) } if err := updateChartfile(src, dest, lname); err != nil { log.Die("Failed to update Chart.yaml: %s", err) } }
// ensureHome ensures that a HELM_HOME exists. func ensureHome(home string) { must := []string{home, filepath.Join(home, CachePath), filepath.Join(home, WorkspacePath), filepath.Join(home, CacheChartPath)} for _, p := range must { if fi, err := os.Stat(p); err != nil { log.Debug("Creating %s", p) if err := os.MkdirAll(p, 0755); err != nil { log.Die("Could not create %q: %s", p, err) } } else if !fi.IsDir() { log.Die("%s must be a directory.", home) } } refi := filepath.Join(home, Configfile) if _, err := os.Stat(refi); err != nil { log.Info("Creating %s", refi) // Attempt to create a Repos.yaml if err := ioutil.WriteFile(refi, []byte(config.DefaultConfigfile), 0755); err != nil { log.Die("Could not create %s: %s", refi, err) } } if err := os.Chdir(home); err != nil { log.Die("Could not change to directory %q: %s", home, err) } }
// gitUpdate updates a Git repo. func gitUpdate(git *vcs.GitRepo) error { if err := git.Update(); err != nil { return err } log.Debug("Updated %s from %s", git.LocalPath(), git.Remote()) return nil }
func marshalAndCreate(o interface{}, ns string, client kubectl.Runner) ([]byte, error) { var b bytes.Buffer if err := codec.JSON.Encode(&b).One(o); err != nil { return nil, err } data := b.Bytes() log.Debug("File: %s", string(data)) return client.Create(data, ns) }
// Copy a directory and its subdirectories. func copyDir(src, dst string) error { var failure error walker := func(fname string, fi os.FileInfo, e error) error { if e != nil { log.Warn("Encounter error walking %q: %s", fname, e) failure = e return nil } log.Debug("Copying %s", fname) rf, err := filepath.Rel(src, fname) if err != nil { log.Warn("Could not find relative path: %s", err) return nil } df := filepath.Join(dst, rf) // Handle directories by creating mirrors. if fi.IsDir() { if err := os.MkdirAll(df, fi.Mode()); err != nil { log.Warn("Could not create %q: %s", df, err) failure = err } return nil } // Otherwise, copy files. in, err := os.Open(fname) if err != nil { log.Warn("Skipping file %s: %s", fname, err) return nil } out, err := os.Create(df) if err != nil { in.Close() log.Warn("Skipping file copy %s: %s", fname, err) return nil } if _, err = io.Copy(out, in); err != nil { log.Warn("Copy from %s to %s failed: %s", fname, df, err) } if err := out.Close(); err != nil { log.Warn("Failed to close %q: %s", df, err) } if err := in.Close(); err != nil { log.Warn("Failed to close reader %q: %s", fname, err) } return nil } filepath.Walk(src, walker) return failure }
func (r *Repos) deleteRepo(name string) error { rpath := filepath.Join(r.Dir, name) if fi, err := os.Stat(rpath); err != nil || !fi.IsDir() { log.Info("Deleted nothing. No repo named %s", name) return nil } log.Debug("Deleting %s", rpath) return os.RemoveAll(rpath) }
// renderTemplate renders a template and values into an output stream. // // tpl should be a string template. func renderTemplate(out io.Writer, tpl string, vals interface{}) error { t, err := template.New("helmTpl").Funcs(sprig.TxtFuncMap()).Parse(tpl) if err != nil { return err } log.Debug("Vals: %#v", vals) if err := t.ExecuteTemplate(out, "helmTpl", vals); err != nil { return err } return nil }
func kubectlDelete(name, ktype, ns string) error { log.Debug("Deleting %s (%s)", name, ktype) a := []string{"delete", ktype, name} if ns != "" { a = append([]string{fmt.Sprintf("--namespace=%q", ns)}, a...) } cmd := exec.Command("kubectl", a...) if d, err := cmd.CombinedOutput(); err != nil { return fmt.Errorf("%s: %s", string(d), err) } return nil }
func repoChartDiff(rpath, initialVersion string) (string, error) { // build git diff-tree command cmd := exec.Command("git", "-C", rpath, "diff-tree", "--name-status", fmt.Sprintf("%s..HEAD", initialVersion)) log.Debug("git diff cmd: %s", cmd.Args) out, err := cmd.CombinedOutput() if err != nil { return "", err } // cleanup any trailing whitespace return strings.TrimSpace(string(out)), nil }
// ParseDir parses all of the manifests inside of a chart directory. // // The directory should be the Chart directory (contains Chart.yaml and manifests/) // // This will return an error if the directory does not exist, or if there is an // error parsing or decoding any yaml files. func ParseDir(chartDir string) ([]*Manifest, error) { dir := filepath.Join(chartDir, "manifests") files := []*Manifest{} if _, err := os.Stat(dir); err != nil { return files, err } // add manifest files walker := func(fname string, fi os.FileInfo, e error) error { log.Debug("Parsing %s", fname) // Chauncey was right. if e != nil { return e } if fi.IsDir() { return nil } if filepath.Ext(fname) != ".yaml" { log.Debug("Skipping %s. Not a YAML file.", fname) return nil } m, err := Parse(fname) if err != nil { return err } files = append(files, m...) return nil } return files, filepath.Walk(dir, walker) }
func fetch(chartName, lname, homedir, chartpath string) { src := filepath.Join(homedir, CachePath, chartpath, chartName) dest := filepath.Join(homedir, WorkspaceChartPath, lname) if fi, err := os.Stat(src); err != nil { log.Die("Chart %s not found in %s", lname, src) } else if !fi.IsDir() { log.Die("Malformed chart %s: Chart must be in a directory.", chartName) } if err := os.MkdirAll(dest, 0755); err != nil { log.Die("Could not create %q: %s", dest, err) } log.Debug("Fetching %s to %s", src, dest) if err := copyDir(src, dest); err != nil { log.Die("Failed copying %s to %s", src, dest) } }
// PrintREADME prints the README file (if it exists) to the console. func PrintREADME(chart, home string) { p := filepath.Join(home, WorkspaceChartPath, chart, "README.*") files, err := filepath.Glob(p) if err != nil || len(files) == 0 { // No README. Skip. log.Debug("No readme in %s", p) return } f, err := os.Open(files[0]) if err != nil { log.Warn("Could not read README: %s", err) return } log.Msg(strings.Repeat("=", 40)) io.Copy(log.Stdout, f) log.Msg(strings.Repeat("=", 40)) f.Close() }
// uploadManifests sends manifests to Kubectl in a particular order. func uploadManifests(c *chart.Chart, namespace string, client kubectl.Runner) error { // Install known kinds in a predictable order. for _, k := range InstallOrder { for _, m := range c.Kind[k] { o := m.VersionedObject o.AddAnnotations(map[string]string{ chart.AnnFile: m.Source, chart.AnnChartVersion: c.Chartfile.Version, chart.AnnChartDesc: c.Chartfile.Description, chart.AnnChartName: c.Chartfile.Name, }) var data []byte var err error if data, err = o.JSON(); err != nil { return err } log.Debug("File: %s", string(data)) out, err := client.Create(data, namespace) log.Msg(string(out)) if err != nil { return err } } } // Install unknown kinds afterward. Order here is not predictable. for _, k := range c.UnknownKinds(InstallOrder) { for _, o := range c.Kind[k] { o.VersionedObject.AddAnnotations(map[string]string{chart.AnnFile: o.Source}) out, err := marshalAndCreate(o.VersionedObject, namespace, client) log.Msg(string(out)) if err != nil { return err } } } return nil }
// checkManifests gets any installed manifests within a chart func checkManifests(chartPath string) ([]string, error) { var foundManifests []string manifests, err := manifest.Files(chartPath) if err != nil { return nil, err } for _, m := range manifests { out := kubeGet(m) if strings.Contains(out, "unable to connect") { return nil, fmt.Errorf(out) } if !strings.Contains(out, "not found") { foundManifests = append(foundManifests, m) } } log.Debug("Found %d installed manifests", len(foundManifests)) return foundManifests, nil }
// kubectlCreate calls `kubectl create` and sends the data via Stdin. // // If dryRun is set to true, then we just output the command that was // going to be run to os.Stdout and return nil. func kubectlCreate(data []byte, ns string, dryRun bool) error { a := []string{"create", "-f", "-"} if ns != "" { a = append([]string{"--namespace=" + ns}, a...) } if dryRun { cmd := "kubectl" for _, arg := range a { cmd = fmt.Sprintf("%s %s", cmd, arg) } cmd = fmt.Sprintf("%s < %s", cmd, data) log.Info(cmd) return nil } c := exec.Command("kubectl", a...) in, err := c.StdinPipe() if err != nil { return err } c.Stdout = os.Stdout c.Stderr = os.Stderr if err := c.Start(); err != nil { return err } log.Debug("File: %s", string(data)) in.Write(data) in.Close() return c.Wait() }
import ( "fmt" "os" "os/exec" "strings" "github.com/helm/helm/log" "github.com/helm/helm/manifest" helm "github.com/helm/helm/util" ) // kubeGetter wraps the kubectl command, override in tests type kubeGetter func(string) string var kubeGet kubeGetter = func(m string) string { log.Debug("Getting manifests from %s", m) a := []string{"get", "-f", m} out, _ := exec.Command("kubectl", a...).CombinedOutput() return string(out) } // Remove removes a chart from the workdir. // // - chart is the source // - homedir is the home directory for the user // - force will remove installed charts from workspace func Remove(chart, homedir string, force bool) { chartPath := helm.WorkspaceChartDirectory(homedir, chart) if _, err := os.Stat(chartPath); err != nil { log.Err("Chart not found. %s", err)
// Walk walks a chart directory and executes generators as it finds them. // // Returns the number of generators executed. // // Walking will error out whenever a generator cannot be completely executed. // This includes cases such as not finding the generator referenced, and // cases where the generator itself exits with a non-zero exit code. func Walk(dir string, exclude []string) (int, error) { excludes := make(map[string]bool, len(exclude)) for i := 0; i < len(exclude); i++ { excludes[filepath.Join(dir, exclude[i])] = true } count := 0 err := filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error { // dive-bomb if we hit an error. if err != nil { return err } // Exclude anything explicitly excluded. if excludes[path] == true { if fi.IsDir() { return filepath.SkipDir } return nil } // Skip directory entries. If the directory prefix is . or _, skip the // contents of the directory as well. if fi.IsDir() { return skip(path) } f, err := os.Open(path) if err != nil { return err } defer f.Close() line, err := readGenerator(f) if err != nil { return err } if line == "" { return nil } // Run the generator. os.Setenv("HELM_GENERATE_COMMAND", line) os.Setenv("HELM_GENERATE_FILE", path) os.Setenv("HELM_GENERATE_DIR", dir) line = os.ExpandEnv(line) os.Setenv("HELM_GENERATE_COMMAND_EXPANDED", line) log.Debug("File: %s, Command: %s", path, line) count++ // Execute the command in the file's directory to make relative // paths usable. origin, err := os.Getwd() if err != nil { log.Warn("Could not get PWD: %s", err) } else if err := os.Chdir(dir); err != nil { log.Warn("Could not change directory to %s: %s", dir, err) } else { origin = dir defer func() { if e := os.Chdir(origin); e != nil { log.Warn("Could not return to %s: %s", origin, e) } }() } err = execute(line) if err != nil { return fmt.Errorf("failed to execute %s (%s): %s", line, path, err) } return nil }) return count, err }