Drop the go-getter dependence.

api/go.mod

@@ -12,7 +12,6 @@ require (
 	github.com/imdario/mergo v0.3.5
 	github.com/pkg/errors v0.8.1
 	github.com/stretchr/testify v1.4.0
-	github.com/yujunz/go-getter v1.5.1-lite.0.20201201013212-6d9c071adddf
 	golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e
 	gopkg.in/yaml.v2 v2.3.0
 	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c

api/loader/fileloader.go

@@ -95,13 +95,6 @@ type fileLoader struct {
 	// Used to clone repositories.
 	cloner git.Cloner
 
-	// If this is non-nil, the files were
-	// obtained from the given resource
-	rscSpec *remoteTargetSpec
-
-	// Used to get resources
-	getter remoteTargetGetter
-
 	// Used to clean up, as needed.
 	cleaner func() error
 }
@@ -134,21 +127,20 @@ func newLoaderOrDie(
 		log.Fatalf("unable to make loader at '%s'; %v", path, err)
 	}
 	return newLoaderAtConfirmedDir(
-		lr, root, fSys, nil, git.ClonerUsingGitExec, getRemoteTarget)
+		lr, root, fSys, nil, git.ClonerUsingGitExec)
 }
 
 // newLoaderAtConfirmedDir returns a new fileLoader with given root.
 func newLoaderAtConfirmedDir(
 	lr LoadRestrictorFunc,
 	root filesys.ConfirmedDir, fSys filesys.FileSystem,
-	referrer *fileLoader, cloner git.Cloner, getter remoteTargetGetter) *fileLoader {
+	referrer *fileLoader, cloner git.Cloner) *fileLoader {
 	return &fileLoader{
 		loadRestrictor: lr,
 		root:           root,
 		referrer:       referrer,
 		fSys:           fSys,
 		cloner:         cloner,
-		getter:         getter,
 		cleaner:        func() error { return nil },
 	}
 }
@@ -179,45 +171,38 @@ func (fl *fileLoader) New(path string) (ifc.Loader, error) {
 		return nil, fmt.Errorf("new root cannot be empty")
 	}
 
-	ldr, errGet := newLoaderAtGetter(path, fl.fSys, nil, fl.cloner, fl.getter)
+	repoSpec, err := git.NewRepoSpecFromUrl(path)
-	if errGet == nil {
+	if err == nil {
-		return ldr, nil
-	}
-
-	repoSpec, errGit := git.NewRepoSpecFromUrl(path)
-	if errGit == nil {
 		// Treat this as git repo clone request.
-		if errGit := fl.errIfRepoCycle(repoSpec); errGit != nil {
+		if err = fl.errIfRepoCycle(repoSpec); err != nil {
-			return nil, errGit
+			return nil, err
 		}
 		return newLoaderAtGitClone(
-			repoSpec, fl.fSys, fl, fl.cloner, fl.getter)
+			repoSpec, fl.fSys, fl, fl.cloner)
 	}
 
 	if filepath.IsAbs(path) {
 		return nil, fmt.Errorf("new root '%s' cannot be absolute", path)
 	}
-	root, errDir := demandDirectoryRoot(fl.fSys, fl.root.Join(path))
+	root, err := demandDirectoryRoot(fl.fSys, fl.root.Join(path))
-	if errDir != nil {
+	if err != nil {
-		return nil, fmt.Errorf(
+		return nil, err
-			"error loading %s with git: %v, dir: %v, get: %v",
-			path, errGit, errDir, errGet)
 	}
-	if errDir := fl.errIfGitContainmentViolation(root); errDir != nil {
+	if err = fl.errIfGitContainmentViolation(root); err != nil {
-		return nil, errDir
+		return nil, err
 	}
-	if errDir := fl.errIfArgEqualOrHigher(root); errDir != nil {
+	if err = fl.errIfArgEqualOrHigher(root); err != nil {
-		return nil, errDir
+		return nil, err
 	}
 	return newLoaderAtConfirmedDir(
-		fl.loadRestrictor, root, fl.fSys, fl, fl.cloner, fl.getter), nil
+		fl.loadRestrictor, root, fl.fSys, fl, fl.cloner), nil
 }
 
 // newLoaderAtGitClone returns a new Loader pinned to a temporary
 // directory holding a cloned git repo.
 func newLoaderAtGitClone(
 	repoSpec *git.RepoSpec, fSys filesys.FileSystem,
-	referrer *fileLoader, cloner git.Cloner, getter remoteTargetGetter) (ifc.Loader, error) {
+	referrer *fileLoader, cloner git.Cloner) (ifc.Loader, error) {
 	cleaner := repoSpec.Cleaner(fSys)
 	err := cloner(repoSpec)
 	if err != nil {
@@ -247,7 +232,6 @@ func newLoaderAtGitClone(
 		repoSpec:       repoSpec,
 		fSys:           fSys,
 		cloner:         cloner,
-		getter:         getter,
 		cleaner:        cleaner,
 	}, nil
 }

api/loader/fileloader_test.go

@@ -388,7 +388,7 @@ whatever
 	}
 	l, err := newLoaderAtGitClone(
 		repoSpec, fSys, nil,
-		git.DoNothingCloner(filesys.ConfirmedDir(coRoot)), getNothing)
+		git.DoNothingCloner(filesys.ConfirmedDir(coRoot)))
 	if err != nil {
 		t.Fatalf("unexpected err: %v\n", err)
 	}
@@ -467,7 +467,7 @@ func TestLoaderDisallowsLocalBaseFromRemoteOverlay(t *testing.T) {
 	}
 	l1, err = newLoaderAtGitClone(
 		repoSpec, fSys, nil,
-		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)), getNothing)
+		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 	if err != nil {
 		t.Fatalf("unexpected err: %v\n", err)
 	}
@@ -506,7 +506,7 @@ func TestLocalLoaderReferencingGitBase(t *testing.T) {
 	}
 	l1 := newLoaderAtConfirmedDir(
 		RestrictionRootOnly, root, fSys, nil,
-		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)), getNothing)
+		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 	if l1.Root() != topDir {
 		t.Fatalf("unexpected root %s", l1.Root())
 	}
@@ -532,7 +532,7 @@ func TestRepoDirectCycleDetection(t *testing.T) {
 	}
 	l1 := newLoaderAtConfirmedDir(
 		RestrictionRootOnly, root, fSys, nil,
-		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)), getNothing)
+		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 	p1 := "github.com/someOrg/someRepo/foo"
 	rs1, err := git.NewRepoSpecFromUrl(p1)
 	if err != nil {
@@ -561,7 +561,7 @@ func TestRepoIndirectCycleDetection(t *testing.T) {
 	}
 	l0 := newLoaderAtConfirmedDir(
 		RestrictionRootOnly, root, fSys, nil,
-		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)), getNothing)
+		git.DoNothingCloner(filesys.ConfirmedDir(cloneRoot)))
 
 	p1 := "github.com/someOrg/someRepo1"
 	p2 := "github.com/someOrg/someRepo2"

api/loader/getter.go

@@ -1,114 +0,0 @@
-// Copyright 2020 The Kubernetes Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package loader
-
-import (
-	"context"
-	"log"
-	"os"
-	"time"
-
-	"github.com/yujunz/go-getter"
-	"sigs.k8s.io/kustomize/api/filesys"
-	"sigs.k8s.io/kustomize/api/ifc"
-	"sigs.k8s.io/kustomize/api/internal/git"
-	"sigs.k8s.io/kustomize/api/internal/utils"
-)
-
-type remoteTargetSpec struct {
-	// Raw is the original resource in kustomization.yaml
-	Raw string
-
-	// Dir is where the resource is saved
-	Dir filesys.ConfirmedDir
-
-	// TempDir is the directory created to hold all resources, including Dir
-	TempDir filesys.ConfirmedDir
-}
-
-// Getter is a function that can gets resource
-type remoteTargetGetter func(rs *remoteTargetSpec) error
-
-func newLoaderAtGetter(
-	raw string,
-	fSys filesys.FileSystem,
-	referrer *fileLoader,
-	cloner git.Cloner,
-	getter remoteTargetGetter) (ifc.Loader, error) {
-	rs := &remoteTargetSpec{
-		Raw: raw,
-	}
-
-	cleaner := func() error {
-		return fSys.RemoveAll(rs.TempDir.String())
-	}
-
-	if err := getter(rs); err != nil {
-		cleaner()
-		return nil, err
-	}
-
-	return &fileLoader{
-		loadRestrictor: RestrictionRootOnly,
-		// TODO(yujunz): limit to getter root
-		root:     rs.Dir,
-		referrer: referrer,
-		fSys:     fSys,
-		cloner:   cloner,
-		rscSpec:  rs,
-		getter:   getter,
-		cleaner:  cleaner,
-	}, nil
-}
-
-func getRemoteTarget(rs *remoteTargetSpec) error {
-	var err error
-
-	rs.TempDir, err = filesys.NewTmpConfirmedDir()
-	if err != nil {
-		return err
-	}
-
-	rs.Dir = filesys.ConfirmedDir(rs.TempDir.Join("repo"))
-
-	// Get the pwd
-	pwd, err := os.Getwd()
-	if err != nil {
-		log.Fatalf("Error getting wd: %s", err)
-	}
-
-	opts := []getter.ClientOption{}
-	client := &getter.Client{
-		Ctx:  context.TODO(),
-		Src:  rs.Raw,
-		Dst:  rs.Dir.String(),
-		Pwd:  pwd,
-		Mode: getter.ClientModeAny,
-		Detectors: []getter.Detector{
-			new(getter.GitHubDetector),
-			new(getter.GitLabDetector),
-			new(getter.GitDetector),
-			new(getter.BitBucketDetector),
-		},
-		Options: opts,
-	}
-	return utils.TimedCall("go-getter client.Get", 21*time.Second, client.Get)
-}
-
-func getNothing(rs *remoteTargetSpec) error {
-	var err error
-	rs.Dir, err = filesys.NewTmpConfirmedDir()
-	if err != nil {
-		return err
-	}
-
-	// Get the pwd
-	pwd, err := os.Getwd()
-	if err != nil {
-		log.Fatalf("Error getting wd: %s", err)
-	}
-
-	_, err = getter.Detect(rs.Raw, pwd, []getter.Detector{})
-	return err
-}

api/loader/loader.go

@@ -5,8 +5,6 @@
 package loader
 
 import (
-	"fmt"
-
 	"sigs.k8s.io/kustomize/api/filesys"
 	"sigs.k8s.io/kustomize/api/ifc"
 	"sigs.k8s.io/kustomize/api/internal/git"
@@ -21,23 +19,16 @@ import (
 func NewLoader(
 	lr LoadRestrictorFunc,
 	target string, fSys filesys.FileSystem) (ifc.Loader, error) {
-	ldr, errGet := newLoaderAtGetter(
+	repoSpec, err := git.NewRepoSpecFromUrl(target)
-		target, fSys, nil, git.ClonerUsingGitExec, getRemoteTarget)
+	if err == nil {
-	if errGet == nil {
-		return ldr, nil
-	}
-	repoSpec, errGit := git.NewRepoSpecFromUrl(target)
-	if errGit == nil {
 		// The target qualifies as a remote git target.
 		return newLoaderAtGitClone(
-			repoSpec, fSys, nil, git.ClonerUsingGitExec, getRemoteTarget)
+			repoSpec, fSys, nil, git.ClonerUsingGitExec)
 	}
-	root, errDir := demandDirectoryRoot(fSys, target)
+	root, err := demandDirectoryRoot(fSys, target)
-	if errDir == nil {
+	if err != nil {
-		return newLoaderAtConfirmedDir(
+		return nil, err
-			lr, root, fSys, nil, git.ClonerUsingGitExec, getRemoteTarget), nil
 	}
-	return nil, fmt.Errorf(
+	return newLoaderAtConfirmedDir(
-		"error creating new loader with git: %v, dir: %v, get: %v",
+		lr, root, fSys, nil, git.ClonerUsingGitExec), nil
-		errGit, errDir, errGet)
 }

kustomize/commands/build/build.go

@@ -4,6 +4,7 @@
 package build
 
 import (
+	"fmt"
 	"io"
 	"log"
 	"path/filepath"
@@ -36,31 +37,45 @@ func NewOptions(p, o string) *Options {
 	}
 }
 
-var examples = `
+type Help struct {
-To generate the resources specified in 'someDir/kustomization.yaml', run
+	Use     string
+	Short   string
+	Long    string
+	Example string
+}
 
-  kustomize build someDir
+func MakeHelp(pgmName, cmdName string) Help {
+	fN := konfig.DefaultKustomizationFileName()
+	return Help{
+		Use:   cmdName + " <dir>",
+		Short: "Build a kustomization target from a directory or URL.",
+		Long: fmt.Sprintf(`Build a set of KRM resources using a '%s' file.
+The <dir> argument must be a path to a directory containing
+'%s', or a git repository URL with a path suffix
+specifying same with respect to the repository root.
+If <dir> is omitted, '.' is assumed.
+`, fN, fN),
+		Example: fmt.Sprintf(`# Build the current working directory
+  %s %s
 
-The default argument to 'build' is '.' (the current working directory).
+# Build some shared configuration directory
+  %s %s /home/config/production
 
-The argument can be a URL resolving to a directory
+# Build from github
-with a kustomization.yaml file, e.g.
+  %s %s \
-
+     https://github.com/kubernetes-sigs/kustomize.git/examples/helloWorld?ref=v1.0.6
-  kustomize build \
+`, pgmName, cmdName, pgmName, cmdName, pgmName, cmdName),
-    github.com/kubernetes-sigs/kustomize/examples/multibases/dev/?ref=v1.0.6
+	}
-
+}
-The URL should be formulated as described at
-https://github.com/hashicorp/go-getter#url-format
-`
 
 // NewCmdBuild creates a new build command.
-func NewCmdBuild(cmdName string, out io.Writer) *cobra.Command {
+func NewCmdBuild(help Help, out io.Writer) *cobra.Command {
 	var o Options
 	cmd := &cobra.Command{
-		Use: cmdName + " {path}",
+		Use:          help.Use,
-		Short: "Print configuration per contents of " +
+		Short:        help.Short,
-			konfig.DefaultKustomizationFileName(),
+		Long:         help.Long,
-		Example:      examples,
+		Example:      help.Example,
 		SilenceUsage: true,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			err := o.Validate(args)
@@ -74,7 +89,7 @@ func NewCmdBuild(cmdName string, out io.Writer) *cobra.Command {
 	cmd.Flags().StringVarP(
 		&o.outputPath,
 		"output", "o", "",
-		"If specified, write the build output to this path.")
+		"If specified, write output to this path.")
 	cmd.Flags().BoolVar(
 		&o.fnOptions.EnableExec, "enable-exec", false, /*do not change!*/
 		"enable support for exec functions -- note: exec functions run arbitrary code -- do not use for untrusted configs!!! (Alpha)")

kustomize/commands/commands.go

@@ -37,14 +37,15 @@ See https://sigs.k8s.io/kustomize
 	pvd := provider.NewDefaultDepProvider()
 	c.AddCommand(
 		completion.NewCommand(),
-		build.NewCmdBuild("build", stdOut),
+		build.NewCmdBuild(
+			build.MakeHelp(konfig.ProgramName, "build"), stdOut),
 		edit.NewCmdEdit(
 			fSys, pvd.GetFieldValidator(), pvd.GetKunstructuredFactory()),
 		create.NewCmdCreate(fSys, pvd.GetKunstructuredFactory()),
 		version.NewCmdVersion(stdOut),
 		openapi.NewCmdOpenAPI(stdOut),
 	)
-	configcobra.AddCommands(c, "kustomize")
+	configcobra.AddCommands(c, konfig.ProgramName)
 
 	c.PersistentFlags().AddGoFlagSet(flag.CommandLine)