Teach oc adm release extract to checkout Git repos

Accept `--git=DIR` and clone the repositories to that path, then
checkout the correct commit.

Author: smarterclayton

contrib/completions/bash/oc

@@ -2,11 +2,21 @@ package release
 
 import (
 	"archive/tar"
+	"bytes"
+	"errors"
 	"fmt"
 	"io"
+	"net/url"
 	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strings"
 	"time"
 
+	"github.com/golang/glog"
+
 	"github.com/spf13/cobra"
 
 	digest "github.com/opencontainers/go-digest"
@@ -38,6 +48,12 @@ func NewExtract(f kcmdutil.Factory, parentName string, streams genericclioptions
 			debugging. Update images contain manifests and metadata about the operators that
 			must be installed on the cluster for a given version.
 
+			Instead of extracting the manifests, you can specify --git=DIR to perform a Git
+			checkout of the source code that comprises the release. A warning will be printed
+			if the component is not associated with source code. The command will not perform
+			any destructive actions on your behalf except for executing a 'git checkout' which
+			may change the current branch.
+
 			Experimental: This command is under active development and may change without notice.
 		`),
 		Run: func(cmd *cobra.Command, args []string) {
@@ -47,6 +63,7 @@ func NewExtract(f kcmdutil.Factory, parentName string, streams genericclioptions
 	}
 	flags := cmd.Flags()
 	flags.StringVarP(&o.RegistryConfig, "registry-config", "a", o.RegistryConfig, "Path to your registry credentials (defaults to ~/.docker/config.json)")
+	flags.StringVar(&o.GitPath, "git", o.GitPath, "Check out the sources that created this release into the provided dir. Repos will be created at <dir>/<host>/<path>. Requires 'git' on your path.")
 	flags.StringVar(&o.From, "from", o.From, "Image containing the release payload.")
 	flags.StringVar(&o.File, "file", o.File, "Extract a single file from the payload to standard output.")
 	flags.StringVar(&o.Directory, "to", o.Directory, "Directory to write release contents to, defaults to the current directory.")
@@ -58,6 +75,9 @@ type ExtractOptions struct {
 
 	From string
 
+	// GitPath is the path of a root directory to extract the source of a release to.
+	GitPath string
+
 	Directory string
 	File      string
 
@@ -67,6 +87,14 @@ type ExtractOptions struct {
 }
 
 func (o *ExtractOptions) Complete(cmd *cobra.Command, args []string) error {
+	switch {
+	case len(args) == 0 && len(o.From) == 0:
+		return fmt.Errorf("must specify an image containing a release payload with --from")
+	case len(args) == 1 && len(o.From) > 0, len(args) > 1:
+		return fmt.Errorf("you may on specify a single image via --from or argument")
+	case len(args) == 1:
+		o.From = args[0]
+	}
 	return nil
 }
 
@@ -78,6 +106,10 @@ func (o *ExtractOptions) Run() error {
 		return fmt.Errorf("only one of --to and --file may be set")
 	}
 
+	if len(o.GitPath) > 0 {
+		return o.extractGit(o.GitPath)
+	}
+
 	dir := o.Directory
 	if err := os.MkdirAll(dir, 0755); err != nil {
 		return err
@@ -147,3 +179,159 @@ func (o *ExtractOptions) Run() error {
 		return opts.Run()
 	}
 }
+
+func (o *ExtractOptions) extractGit(dir string) error {
+	if err := os.MkdirAll(dir, 0750); err != nil {
+		return err
+	}
+
+	release, err := NewInfoOptions(o.IOStreams).LoadReleaseInfo(o.From)
+	if err != nil {
+		return err
+	}
+
+	cloner := &git{}
+
+	hadErrors := false
+	alreadyExtracted := make(map[string]string)
+	for _, ref := range release.References.Spec.Tags {
+		repo := ref.Annotations["io.openshift.build.source-location"]
+		commit := ref.Annotations["io.openshift.build.commit.id"]
+		if len(repo) == 0 || len(commit) == 0 {
+			glog.V(2).Infof("Tag %s has no source info", ref.Name)
+			continue
+		}
+		if oldCommit, ok := alreadyExtracted[repo]; ok {
+			if oldCommit != commit {
+				fmt.Fprintf(o.ErrOut, "warning: Repo %s referenced more than once with different commits, only checking out the first reference\n", repo)
+			}
+			continue
+		}
+		alreadyExtracted[repo] = commit
+
+		u, err := sourceLocationAsURL(repo)
+		if err != nil {
+			return err
+		}
+		gitPath := u.Path
+		if strings.HasSuffix(gitPath, ".git") {
+			gitPath = strings.TrimSuffix(gitPath, ".git")
+		}
+		gitPath = path.Clean(gitPath)
+		basePath := filepath.Join(dir, u.Host, filepath.FromSlash(gitPath))
+
+		var git *git
+		fi, err := os.Stat(basePath)
+		if err != nil {
+			if !os.IsNotExist(err) {
+				return err
+			}
+			if err := os.MkdirAll(basePath, 0750); err != nil {
+				return err
+			}
+		} else {
+			if !fi.IsDir() {
+				return fmt.Errorf("repo path %s is not a directory", basePath)
+			}
+		}
+		git, err = cloner.ChangeContext(basePath)
+		if err != nil {
+			if err != noSuchRepo {
+				return err
+			}
+			glog.V(2).Infof("Cloning %s ...", repo)
+			if err := git.Clone(repo, o.Out, o.ErrOut); err != nil {
+				hadErrors = true
+				fmt.Fprintf(o.ErrOut, "error: cloning %s: %v\n", repo, err)
+				continue
+			}
+		}
+		glog.V(2).Infof("Checkout %s from %s ...", commit, repo)
+		if err := git.CheckoutCommit(repo, commit); err != nil {
+			hadErrors = true
+			fmt.Fprintf(o.ErrOut, "error: checking out commit for %s: %v\n", repo, err)
+			continue
+		}
+	}
+	if hadErrors {
+		return kcmdutil.ErrExit
+	}
+	return nil
+}
+
+type git struct {
+	path string
+}
+
+var noSuchRepo = errors.New("location is not a git repo")
+
+func (g *git) exec(command ...string) (string, error) {
+	buf := &bytes.Buffer{}
+	bufErr := &bytes.Buffer{}
+	cmd := exec.Command("git", append([]string{"-C", g.path}, command...)...)
+	glog.V(5).Infof("Executing git: %v\n", cmd.Args)
+	cmd.Stdout = buf
+	cmd.Stderr = bufErr
+	err := cmd.Run()
+	if err != nil {
+		return bufErr.String(), err
+	}
+	return buf.String(), nil
+}
+
+func (g *git) streamExec(out, errOut io.Writer, command ...string) error {
+	cmd := exec.Command("git", append([]string{"-C", g.path}, command...)...)
+	cmd.Stdout = out
+	cmd.Stderr = errOut
+	return cmd.Run()
+}
+
+func (g *git) ChangeContext(path string) (*git, error) {
+	location := &git{path: path}
+	if errOut, err := location.exec("rev-parse", "--git-dir"); err != nil {
+		if strings.Contains(errOut, "not a git repository") {
+			return location, noSuchRepo
+		}
+		return location, err
+	}
+	return location, nil
+}
+
+func (g *git) Clone(repository string, out, errOut io.Writer) error {
+	return (&git{}).streamExec(out, errOut, "clone", repository, g.path)
+}
+
+func (g *git) parent() *git {
+	return &git{path: filepath.Dir(g.path)}
+}
+
+func (g *git) basename() string {
+	return filepath.Base(g.path)
+}
+
+func (g *git) CheckoutCommit(repo, commit string) error {
+	_, err := g.exec("rev-parse", commit)
+	if err == nil {
+		return nil
+	}
+
+	// try to fetch by URL
+	if _, err := g.exec("fetch", repo); err == nil {
+		if _, err := g.exec("rev-parse", commit); err == nil {
+			return nil
+		}
+	}
+
+	// TODO: what if that transport URL does not exist?
+
+	return fmt.Errorf("could not locate commit %s", commit)
+}
+
+var reMatch = regexp.MustCompile(`^([a-zA-Z0-9\-\_]+)@([^:]+):(.+)$`)
+
+func sourceLocationAsURL(location string) (*url.URL, error) {
+	if matches := reMatch.FindStringSubmatch(location); matches != nil {
+		return &url.URL{Scheme: "git", User: url.UserPassword(matches[1], ""), Host: matches[2], Path: matches[3]}, nil
+	}
+	return url.Parse(location)
+}