add local fork of github.com/docker/docker/builder/remotecontext
Adds a local fork of this package for use in the classic builder.
Code was taken at commit [d33d46d01656e1d9ee26743f0c0d7779f685dd4e][1].
Migration was done using the following steps:
# install filter-repo (https://github.com/newren/git-filter-repo/blob/main/INSTALL.md)
brew install git-filter-repo
# create a temporary clone of docker
cd ~/Projects
git clone https://github.com/docker/docker.git build_context_temp
cd build_context_temp
# commit taken from
git rev-parse --verify HEAD
d33d46d01656e1d9ee26743f0c0d7779f685dd4e
git filter-repo --analyze
# remove all code, except for the remotecontext packages, and move to build/internal docs and previous locations of it
git filter-repo \
--path 'builder/remotecontext/git' \
--path 'builder/remotecontext/urlutil' \
--path-rename builder/remotecontext:cli/command/image/build/internal
# go to the target repository
cd ~/go/src/github.com/docker/cli
# create a branch to work with
git checkout -b fork_remotecontext
# add the temporary repository as an upstream and make sure it's up-to-date
git remote add build_context_temp ~/Projects/build_context_temp
git fetch build_context_temp
# merge the upstream code
git merge --allow-unrelated-histories --signoff -S build_context_temp/master
[1]: https://github.com/docker/docker/d33d46d01656e1d9ee26743f0c0d7779f685dd4e
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn
@ -16,7 +16,7 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/docker/docker/builder/remotecontext/git"
|
||||
"github.com/docker/cli/cli/command/image/build/internal/git"
|
||||
"github.com/docker/docker/pkg/progress"
|
||||
"github.com/docker/docker/pkg/streamformatter"
|
||||
"github.com/moby/go-archive"
|
||||
|
||||
@ -4,7 +4,7 @@ import (
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
"github.com/docker/docker/builder/remotecontext/urlutil"
|
||||
"github.com/docker/cli/cli/command/image/build/internal/urlutil"
|
||||
)
|
||||
|
||||
// ContextType describes the type (source) of build-context specified.
|
||||
|
||||
241
cli/command/image/build/internal/git/gitutils.go
Normal file
241
cli/command/image/build/internal/git/gitutils.go
Normal file
@ -0,0 +1,241 @@
|
||||
package git
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
|
||||
"github.com/moby/sys/symlink"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
type gitRepo struct {
|
||||
remote string
|
||||
ref string
|
||||
subdir string
|
||||
|
||||
isolateConfig bool
|
||||
}
|
||||
|
||||
// CloneOption changes the behaviour of Clone().
|
||||
type CloneOption func(*gitRepo)
|
||||
|
||||
// WithIsolatedConfig disables reading the user or system gitconfig files when
|
||||
// performing Git operations.
|
||||
func WithIsolatedConfig(v bool) CloneOption {
|
||||
return func(gr *gitRepo) {
|
||||
gr.isolateConfig = v
|
||||
}
|
||||
}
|
||||
|
||||
// Clone clones a repository into a newly created directory which
|
||||
// will be under "docker-build-git"
|
||||
func Clone(remoteURL string, opts ...CloneOption) (string, error) {
|
||||
repo, err := parseRemoteURL(remoteURL)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
for _, opt := range opts {
|
||||
opt(&repo)
|
||||
}
|
||||
|
||||
return repo.clone()
|
||||
}
|
||||
|
||||
func (repo gitRepo) clone() (checkoutDir string, retErr error) {
|
||||
fetch := fetchArgs(repo.remote, repo.ref)
|
||||
|
||||
root, err := os.MkdirTemp("", "docker-build-git")
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
defer func() {
|
||||
if retErr != nil {
|
||||
_ = os.RemoveAll(root)
|
||||
}
|
||||
}()
|
||||
|
||||
if out, err := repo.gitWithinDir(root, "init"); err != nil {
|
||||
return "", errors.Wrapf(err, "failed to init repo at %s: %s", root, out)
|
||||
}
|
||||
|
||||
// Add origin remote for compatibility with previous implementation that
|
||||
// used "git clone" and also to make sure local refs are created for branches
|
||||
if out, err := repo.gitWithinDir(root, "remote", "add", "origin", repo.remote); err != nil {
|
||||
return "", errors.Wrapf(err, "failed add origin repo at %s: %s", repo.remote, out)
|
||||
}
|
||||
|
||||
if output, err := repo.gitWithinDir(root, fetch...); err != nil {
|
||||
return "", errors.Wrapf(err, "error fetching: %s", output)
|
||||
}
|
||||
|
||||
checkoutDir, err = repo.checkout(root)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
|
||||
cmd := exec.Command("git", "submodule", "update", "--init", "--recursive", "--depth=1")
|
||||
cmd.Dir = root
|
||||
output, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
return "", errors.Wrapf(err, "error initializing submodules: %s", output)
|
||||
}
|
||||
|
||||
return checkoutDir, nil
|
||||
}
|
||||
|
||||
func parseRemoteURL(remoteURL string) (gitRepo, error) {
|
||||
repo := gitRepo{}
|
||||
|
||||
if !isGitTransport(remoteURL) {
|
||||
remoteURL = "https://" + remoteURL
|
||||
}
|
||||
|
||||
if strings.HasPrefix(remoteURL, "git@") {
|
||||
// git@.. is not an URL, so cannot be parsed as URL
|
||||
var fragment string
|
||||
repo.remote, fragment, _ = strings.Cut(remoteURL, "#")
|
||||
repo.ref, repo.subdir = getRefAndSubdir(fragment)
|
||||
} else {
|
||||
u, err := url.Parse(remoteURL)
|
||||
if err != nil {
|
||||
return repo, err
|
||||
}
|
||||
|
||||
repo.ref, repo.subdir = getRefAndSubdir(u.Fragment)
|
||||
u.Fragment = ""
|
||||
repo.remote = u.String()
|
||||
}
|
||||
|
||||
if strings.HasPrefix(repo.ref, "-") {
|
||||
return gitRepo{}, errors.Errorf("invalid refspec: %s", repo.ref)
|
||||
}
|
||||
|
||||
return repo, nil
|
||||
}
|
||||
|
||||
func getRefAndSubdir(fragment string) (ref string, subdir string) {
|
||||
ref, subdir, _ = strings.Cut(fragment, ":")
|
||||
if ref == "" {
|
||||
ref = "master"
|
||||
}
|
||||
return ref, subdir
|
||||
}
|
||||
|
||||
func fetchArgs(remoteURL string, ref string) []string {
|
||||
args := []string{"fetch"}
|
||||
|
||||
if supportsShallowClone(remoteURL) {
|
||||
args = append(args, "--depth", "1")
|
||||
}
|
||||
|
||||
return append(args, "origin", "--", ref)
|
||||
}
|
||||
|
||||
// Check if a given git URL supports a shallow git clone,
|
||||
// i.e. it is a non-HTTP server or a smart HTTP server.
|
||||
func supportsShallowClone(remoteURL string) bool {
|
||||
if scheme := getScheme(remoteURL); scheme == "http" || scheme == "https" {
|
||||
// Check if the HTTP server is smart
|
||||
|
||||
// Smart servers must correctly respond to a query for the git-upload-pack service
|
||||
serviceURL := remoteURL + "/info/refs?service=git-upload-pack"
|
||||
|
||||
// Try a HEAD request and fallback to a Get request on error
|
||||
res, err := http.Head(serviceURL) // #nosec G107
|
||||
if err != nil || res.StatusCode != http.StatusOK {
|
||||
res, err = http.Get(serviceURL) // #nosec G107
|
||||
if err == nil {
|
||||
res.Body.Close()
|
||||
}
|
||||
if err != nil || res.StatusCode != http.StatusOK {
|
||||
// request failed
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
if res.Header.Get("Content-Type") != "application/x-git-upload-pack-advertisement" {
|
||||
// Fallback, not a smart server
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
// Non-HTTP protocols always support shallow clones
|
||||
return true
|
||||
}
|
||||
|
||||
func (repo gitRepo) checkout(root string) (string, error) {
|
||||
// Try checking out by ref name first. This will work on branches and sets
|
||||
// .git/HEAD to the current branch name
|
||||
if output, err := repo.gitWithinDir(root, "checkout", repo.ref); err != nil {
|
||||
// If checking out by branch name fails check out the last fetched ref
|
||||
if _, err2 := repo.gitWithinDir(root, "checkout", "FETCH_HEAD"); err2 != nil {
|
||||
return "", errors.Wrapf(err, "error checking out %s: %s", repo.ref, output)
|
||||
}
|
||||
}
|
||||
|
||||
if repo.subdir != "" {
|
||||
newCtx, err := symlink.FollowSymlinkInScope(filepath.Join(root, repo.subdir), root)
|
||||
if err != nil {
|
||||
return "", errors.Wrapf(err, "error setting git context, %q not within git root", repo.subdir)
|
||||
}
|
||||
|
||||
fi, err := os.Stat(newCtx)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if !fi.IsDir() {
|
||||
return "", errors.Errorf("error setting git context, not a directory: %s", newCtx)
|
||||
}
|
||||
root = newCtx
|
||||
}
|
||||
|
||||
return root, nil
|
||||
}
|
||||
|
||||
func (repo gitRepo) gitWithinDir(dir string, args ...string) ([]byte, error) {
|
||||
args = append([]string{"-c", "protocol.file.allow=never"}, args...) // Block sneaky repositories from using repos from the filesystem as submodules.
|
||||
cmd := exec.Command("git", args...)
|
||||
cmd.Dir = dir
|
||||
// Disable unsafe remote protocols.
|
||||
cmd.Env = append(os.Environ(), "GIT_PROTOCOL_FROM_USER=0")
|
||||
|
||||
if repo.isolateConfig {
|
||||
cmd.Env = append(cmd.Env,
|
||||
"GIT_CONFIG_NOSYSTEM=1", // Disable reading from system gitconfig.
|
||||
"HOME=/dev/null", // Disable reading from user gitconfig.
|
||||
)
|
||||
}
|
||||
|
||||
return cmd.CombinedOutput()
|
||||
}
|
||||
|
||||
// isGitTransport returns true if the provided str is a git transport by inspecting
|
||||
// the prefix of the string for known protocols used in git.
|
||||
func isGitTransport(str string) bool {
|
||||
if strings.HasPrefix(str, "git@") {
|
||||
return true
|
||||
}
|
||||
|
||||
switch getScheme(str) {
|
||||
case "git", "http", "https", "ssh":
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
// getScheme returns addresses' scheme in lowercase, or an empty
|
||||
// string in case address is an invalid URL.
|
||||
func getScheme(address string) string {
|
||||
u, err := url.Parse(address)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return u.Scheme
|
||||
}
|
||||
381
cli/command/image/build/internal/git/gitutils_test.go
Normal file
381
cli/command/image/build/internal/git/gitutils_test.go
Normal file
@ -0,0 +1,381 @@
|
||||
package git
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"net/http"
|
||||
"net/http/cgi"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/google/go-cmp/cmp"
|
||||
"gotest.tools/v3/assert"
|
||||
is "gotest.tools/v3/assert/cmp"
|
||||
)
|
||||
|
||||
func TestParseRemoteURL(t *testing.T) {
|
||||
tests := []struct {
|
||||
doc string
|
||||
url string
|
||||
expected gitRepo
|
||||
}{
|
||||
{
|
||||
doc: "git scheme uppercase, no url-fragment",
|
||||
url: "GIT://github.com/user/repo.git",
|
||||
expected: gitRepo{
|
||||
remote: "git://github.com/user/repo.git",
|
||||
ref: "master",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "git scheme, no url-fragment",
|
||||
url: "git://github.com/user/repo.git",
|
||||
expected: gitRepo{
|
||||
remote: "git://github.com/user/repo.git",
|
||||
ref: "master",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "git scheme, with url-fragment",
|
||||
url: "git://github.com/user/repo.git#mybranch:mydir/mysubdir/",
|
||||
expected: gitRepo{
|
||||
remote: "git://github.com/user/repo.git",
|
||||
ref: "mybranch",
|
||||
subdir: "mydir/mysubdir/",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "https scheme, no url-fragment",
|
||||
url: "https://github.com/user/repo.git",
|
||||
expected: gitRepo{
|
||||
remote: "https://github.com/user/repo.git",
|
||||
ref: "master",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "https scheme, with url-fragment",
|
||||
url: "https://github.com/user/repo.git#mybranch:mydir/mysubdir/",
|
||||
expected: gitRepo{
|
||||
remote: "https://github.com/user/repo.git",
|
||||
ref: "mybranch",
|
||||
subdir: "mydir/mysubdir/",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "git@, no url-fragment",
|
||||
url: "git@github.com:user/repo.git",
|
||||
expected: gitRepo{
|
||||
remote: "git@github.com:user/repo.git",
|
||||
ref: "master",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "git@, with url-fragment",
|
||||
url: "git@github.com:user/repo.git#mybranch:mydir/mysubdir/",
|
||||
expected: gitRepo{
|
||||
remote: "git@github.com:user/repo.git",
|
||||
ref: "mybranch",
|
||||
subdir: "mydir/mysubdir/",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "ssh, no url-fragment",
|
||||
url: "ssh://github.com/user/repo.git",
|
||||
expected: gitRepo{
|
||||
remote: "ssh://github.com/user/repo.git",
|
||||
ref: "master",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "ssh, with url-fragment",
|
||||
url: "ssh://github.com/user/repo.git#mybranch:mydir/mysubdir/",
|
||||
expected: gitRepo{
|
||||
remote: "ssh://github.com/user/repo.git",
|
||||
ref: "mybranch",
|
||||
subdir: "mydir/mysubdir/",
|
||||
},
|
||||
},
|
||||
{
|
||||
doc: "ssh, with url-fragment and user",
|
||||
url: "ssh://foo%40barcorp.com@github.com/user/repo.git#mybranch:mydir/mysubdir/",
|
||||
expected: gitRepo{
|
||||
remote: "ssh://foo%40barcorp.com@github.com/user/repo.git",
|
||||
ref: "mybranch",
|
||||
subdir: "mydir/mysubdir/",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.doc, func(t *testing.T) {
|
||||
repo, err := parseRemoteURL(tc.url)
|
||||
assert.NilError(t, err)
|
||||
assert.Check(t, is.DeepEqual(tc.expected, repo, cmp.AllowUnexported(gitRepo{})))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCloneArgsSmartHttp(t *testing.T) {
|
||||
mux := http.NewServeMux()
|
||||
server := httptest.NewServer(mux)
|
||||
serverURL, _ := url.Parse(server.URL)
|
||||
|
||||
serverURL.Path = "/repo.git"
|
||||
|
||||
mux.HandleFunc("/repo.git/info/refs", func(w http.ResponseWriter, r *http.Request) {
|
||||
q := r.URL.Query().Get("service")
|
||||
w.Header().Set("Content-Type", fmt.Sprintf("application/x-%s-advertisement", q))
|
||||
})
|
||||
|
||||
args := fetchArgs(serverURL.String(), "master")
|
||||
exp := []string{"fetch", "--depth", "1", "origin", "--", "master"}
|
||||
assert.Check(t, is.DeepEqual(exp, args))
|
||||
}
|
||||
|
||||
func TestCloneArgsDumbHttp(t *testing.T) {
|
||||
mux := http.NewServeMux()
|
||||
server := httptest.NewServer(mux)
|
||||
serverURL, _ := url.Parse(server.URL)
|
||||
|
||||
serverURL.Path = "/repo.git"
|
||||
|
||||
mux.HandleFunc("/repo.git/info/refs", func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "text/plain")
|
||||
})
|
||||
|
||||
args := fetchArgs(serverURL.String(), "master")
|
||||
exp := []string{"fetch", "origin", "--", "master"}
|
||||
assert.Check(t, is.DeepEqual(exp, args))
|
||||
}
|
||||
|
||||
func TestCloneArgsGit(t *testing.T) {
|
||||
args := fetchArgs("git://github.com/docker/docker", "master")
|
||||
exp := []string{"fetch", "--depth", "1", "origin", "--", "master"}
|
||||
assert.Check(t, is.DeepEqual(exp, args))
|
||||
}
|
||||
|
||||
func gitGetConfig(name string) string {
|
||||
b, err := gitRepo{}.gitWithinDir("", "config", "--get", name)
|
||||
if err != nil {
|
||||
// since we are interested in empty or non empty string,
|
||||
// we can safely ignore the err here.
|
||||
return ""
|
||||
}
|
||||
return strings.TrimSpace(string(b))
|
||||
}
|
||||
|
||||
func TestCheckoutGit(t *testing.T) {
|
||||
root := t.TempDir()
|
||||
|
||||
gitpath, err := exec.LookPath("git")
|
||||
assert.NilError(t, err)
|
||||
gitversion, _ := exec.Command(gitpath, "version").CombinedOutput()
|
||||
t.Logf("%s", gitversion) // E.g. "git version 2.30.2"
|
||||
|
||||
// Serve all repositories under root using the Smart HTTP protocol so
|
||||
// they can be cloned. The Dumb HTTP protocol is incompatible with
|
||||
// shallow cloning but we unconditionally shallow-clone submodules, and
|
||||
// we explicitly disable the file protocol.
|
||||
// (Another option would be to use `git daemon` and the Git protocol,
|
||||
// but that listens on a fixed port number which is a recipe for
|
||||
// disaster in CI. Funnily enough, `git daemon --port=0` works but there
|
||||
// is no easy way to discover which port got picked!)
|
||||
|
||||
// Associate git-http-backend logs with the current (sub)test.
|
||||
// Incompatible with parallel subtests.
|
||||
currentSubtest := t
|
||||
githttp := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
var logs bytes.Buffer
|
||||
(&cgi.Handler{
|
||||
Path: gitpath,
|
||||
Args: []string{"http-backend"},
|
||||
Dir: root,
|
||||
Env: []string{
|
||||
"GIT_PROJECT_ROOT=" + root,
|
||||
"GIT_HTTP_EXPORT_ALL=1",
|
||||
},
|
||||
Stderr: &logs,
|
||||
}).ServeHTTP(w, r)
|
||||
if logs.Len() == 0 {
|
||||
return
|
||||
}
|
||||
for {
|
||||
line, err := logs.ReadString('\n')
|
||||
currentSubtest.Log("git-http-backend: " + line)
|
||||
if err != nil {
|
||||
break
|
||||
}
|
||||
}
|
||||
})
|
||||
server := httptest.NewServer(&githttp)
|
||||
defer server.Close()
|
||||
|
||||
eol := "\n"
|
||||
autocrlf := gitGetConfig("core.autocrlf")
|
||||
switch autocrlf {
|
||||
case "true":
|
||||
eol = "\r\n"
|
||||
case "false", "input", "":
|
||||
// accepted values
|
||||
default:
|
||||
t.Logf(`unknown core.autocrlf value: "%s"`, autocrlf)
|
||||
}
|
||||
|
||||
must := func(out []byte, err error) {
|
||||
t.Helper()
|
||||
if len(out) > 0 {
|
||||
t.Logf("%s", out)
|
||||
}
|
||||
assert.NilError(t, err)
|
||||
}
|
||||
|
||||
gitDir := filepath.Join(root, "repo")
|
||||
must(gitRepo{}.gitWithinDir(root, "-c", "init.defaultBranch=master", "init", gitDir))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "config", "user.email", "test@docker.com"))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "config", "user.name", "Docker test"))
|
||||
assert.NilError(t, os.WriteFile(filepath.Join(gitDir, "Dockerfile"), []byte("FROM scratch"), 0o644))
|
||||
|
||||
subDir := filepath.Join(gitDir, "subdir")
|
||||
assert.NilError(t, os.Mkdir(subDir, 0o755))
|
||||
assert.NilError(t, os.WriteFile(filepath.Join(subDir, "Dockerfile"), []byte("FROM scratch\nEXPOSE 5000"), 0o644))
|
||||
|
||||
if runtime.GOOS != "windows" {
|
||||
assert.NilError(t, os.Symlink("../subdir", filepath.Join(gitDir, "parentlink")))
|
||||
assert.NilError(t, os.Symlink("/subdir", filepath.Join(gitDir, "absolutelink")))
|
||||
}
|
||||
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "add", "-A"))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "commit", "-am", "First commit"))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "checkout", "-b", "test"))
|
||||
|
||||
assert.NilError(t, os.WriteFile(filepath.Join(gitDir, "Dockerfile"), []byte("FROM scratch\nEXPOSE 3000"), 0o644))
|
||||
assert.NilError(t, os.WriteFile(filepath.Join(subDir, "Dockerfile"), []byte("FROM busybox\nEXPOSE 5000"), 0o644))
|
||||
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "add", "-A"))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "commit", "-am", "Branch commit"))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "checkout", "master"))
|
||||
|
||||
// set up submodule
|
||||
subrepoDir := filepath.Join(root, "subrepo")
|
||||
must(gitRepo{}.gitWithinDir(root, "-c", "init.defaultBranch=master", "init", subrepoDir))
|
||||
must(gitRepo{}.gitWithinDir(subrepoDir, "config", "user.email", "test@docker.com"))
|
||||
must(gitRepo{}.gitWithinDir(subrepoDir, "config", "user.name", "Docker test"))
|
||||
|
||||
assert.NilError(t, os.WriteFile(filepath.Join(subrepoDir, "subfile"), []byte("subcontents"), 0o644))
|
||||
|
||||
must(gitRepo{}.gitWithinDir(subrepoDir, "add", "-A"))
|
||||
must(gitRepo{}.gitWithinDir(subrepoDir, "commit", "-am", "Subrepo initial"))
|
||||
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "submodule", "add", server.URL+"/subrepo", "sub"))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "add", "-A"))
|
||||
must(gitRepo{}.gitWithinDir(gitDir, "commit", "-am", "With submodule"))
|
||||
|
||||
type singleCase struct {
|
||||
frag string
|
||||
exp string
|
||||
fail bool
|
||||
submodule bool
|
||||
}
|
||||
|
||||
cases := []singleCase{
|
||||
{"", "FROM scratch", false, true},
|
||||
{"master", "FROM scratch", false, true},
|
||||
{":subdir", "FROM scratch" + eol + "EXPOSE 5000", false, false},
|
||||
{":nosubdir", "", true, false}, // missing directory error
|
||||
{":Dockerfile", "", true, false}, // not a directory error
|
||||
{"master:nosubdir", "", true, false},
|
||||
{"master:subdir", "FROM scratch" + eol + "EXPOSE 5000", false, false},
|
||||
{"master:../subdir", "", true, false},
|
||||
{"test", "FROM scratch" + eol + "EXPOSE 3000", false, false},
|
||||
{"test:", "FROM scratch" + eol + "EXPOSE 3000", false, false},
|
||||
{"test:subdir", "FROM busybox" + eol + "EXPOSE 5000", false, false},
|
||||
}
|
||||
|
||||
if runtime.GOOS != "windows" {
|
||||
// Windows GIT (2.7.1 x64) does not support parentlink/absolutelink. Sample output below
|
||||
// git --work-tree .\repo --git-dir .\repo\.git add -A
|
||||
// error: readlink("absolutelink"): Function not implemented
|
||||
// error: unable to index file absolutelink
|
||||
// fatal: adding files failed
|
||||
cases = append(cases, singleCase{frag: "master:absolutelink", exp: "FROM scratch" + eol + "EXPOSE 5000", fail: false})
|
||||
cases = append(cases, singleCase{frag: "master:parentlink", exp: "FROM scratch" + eol + "EXPOSE 5000", fail: false})
|
||||
}
|
||||
|
||||
for _, c := range cases {
|
||||
t.Run(c.frag, func(t *testing.T) {
|
||||
currentSubtest = t
|
||||
ref, subdir := getRefAndSubdir(c.frag)
|
||||
r, err := gitRepo{remote: server.URL + "/repo", ref: ref, subdir: subdir}.clone()
|
||||
|
||||
if c.fail {
|
||||
assert.Check(t, is.ErrorContains(err, ""))
|
||||
return
|
||||
}
|
||||
assert.NilError(t, err)
|
||||
defer os.RemoveAll(r)
|
||||
if c.submodule {
|
||||
b, err := os.ReadFile(filepath.Join(r, "sub/subfile"))
|
||||
assert.NilError(t, err)
|
||||
assert.Check(t, is.Equal("subcontents", string(b)))
|
||||
} else {
|
||||
_, err := os.Stat(filepath.Join(r, "sub/subfile"))
|
||||
assert.ErrorContains(t, err, "")
|
||||
assert.Assert(t, os.IsNotExist(err))
|
||||
}
|
||||
|
||||
b, err := os.ReadFile(filepath.Join(r, "Dockerfile"))
|
||||
assert.NilError(t, err)
|
||||
assert.Check(t, is.Equal(c.exp, string(b)))
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidGitTransport(t *testing.T) {
|
||||
gitUrls := []string{
|
||||
"git://github.com/docker/docker",
|
||||
"git@github.com:docker/docker.git",
|
||||
"git@bitbucket.org:atlassianlabs/atlassian-docker.git",
|
||||
"https://github.com/docker/docker.git",
|
||||
"http://github.com/docker/docker.git",
|
||||
"http://github.com/docker/docker.git#branch",
|
||||
"http://github.com/docker/docker.git#:dir",
|
||||
}
|
||||
incompleteGitUrls := []string{
|
||||
"github.com/docker/docker",
|
||||
}
|
||||
|
||||
for _, url := range gitUrls {
|
||||
if !isGitTransport(url) {
|
||||
t.Fatalf("%q should be detected as valid Git prefix", url)
|
||||
}
|
||||
}
|
||||
|
||||
for _, url := range incompleteGitUrls {
|
||||
if isGitTransport(url) {
|
||||
t.Fatalf("%q should not be detected as valid Git prefix", url)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestGitInvalidRef(t *testing.T) {
|
||||
gitUrls := []string{
|
||||
"git://github.com/moby/moby#--foo bar",
|
||||
"git@github.com/moby/moby#--upload-pack=sleep;:",
|
||||
"git@g.com:a/b.git#-B",
|
||||
"git@g.com:a/b.git#with space",
|
||||
}
|
||||
|
||||
for _, url := range gitUrls {
|
||||
_, err := Clone(url)
|
||||
assert.Assert(t, err != nil)
|
||||
// On Windows, git has different case for the "invalid refspec" error,
|
||||
// so we can't use ErrorContains.
|
||||
assert.Check(t, is.Contains(strings.ToLower(err.Error()), "invalid refspec"))
|
||||
}
|
||||
}
|
||||
87
cli/command/image/build/internal/urlutil/urlutil.go
Normal file
87
cli/command/image/build/internal/urlutil/urlutil.go
Normal file
@ -0,0 +1,87 @@
|
||||
// Package urlutil provides helper function to check if a given build-context
|
||||
// location should be considered a URL or a remote Git repository.
|
||||
//
|
||||
// This package is specifically written for use with docker build contexts, and
|
||||
// should not be used as a general-purpose utility.
|
||||
package urlutil
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
"github.com/docker/cli/internal/lazyregexp"
|
||||
)
|
||||
|
||||
// urlPathWithFragmentSuffix matches fragments to use as Git reference and build
|
||||
// context from the Git repository. See IsGitURL for details.
|
||||
var urlPathWithFragmentSuffix = lazyregexp.New(`\.git(?:#.+)?$`)
|
||||
|
||||
// IsURL returns true if the provided str is an HTTP(S) URL by checking if it
|
||||
// has a http:// or https:// scheme. No validation is performed to verify if the
|
||||
// URL is well-formed.
|
||||
func IsURL(str string) bool {
|
||||
return strings.HasPrefix(str, "https://") || strings.HasPrefix(str, "http://")
|
||||
}
|
||||
|
||||
// IsGitURL returns true if the provided str is a remote git repository "URL".
|
||||
//
|
||||
// This function only performs a rudimentary check (no validation is performed
|
||||
// to ensure the URL is well-formed), and is written specifically for use with
|
||||
// docker build, with some logic for backward compatibility with older versions
|
||||
// of docker: do not use this function as a general-purpose utility.
|
||||
//
|
||||
// The following patterns are considered to be a Git URL:
|
||||
//
|
||||
// - https://(.*).git(?:#.+)?$ git repository URL with optional fragment, as known to be used by GitHub and GitLab.
|
||||
// - http://(.*).git(?:#.+)?$ same, but non-TLS
|
||||
// - git://(.*) URLs using git:// scheme
|
||||
// - git@(.*)
|
||||
// - github.com/ see description below
|
||||
//
|
||||
// The github.com/ prefix is a special case used to treat context-paths
|
||||
// starting with "github.com/" as a git URL if the given path does not
|
||||
// exist locally. The "github.com/" prefix is kept for backward compatibility,
|
||||
// and is a legacy feature.
|
||||
//
|
||||
// Going forward, no additional prefixes should be added, and users should
|
||||
// be encouraged to use explicit URLs (https://github.com/user/repo.git) instead.
|
||||
//
|
||||
// Note that IsGitURL does not check if "github.com/" prefixes exist as a local
|
||||
// path. Code using this function should check if the path exists locally before
|
||||
// using it as a URL.
|
||||
//
|
||||
// # Fragments
|
||||
//
|
||||
// Git URLs accept context configuration in their fragment section, separated by
|
||||
// a colon (`:`). The first part represents the reference to check out, and can
|
||||
// be either a branch, a tag, or a remote reference. The second part represents
|
||||
// a subdirectory inside the repository to use as the build context.
|
||||
//
|
||||
// For example,the following URL uses a directory named "docker" in the branch
|
||||
// "container" in the https://github.com/myorg/my-repo.git repository:
|
||||
//
|
||||
// https://github.com/myorg/my-repo.git#container:docker
|
||||
//
|
||||
// The following table represents all the valid suffixes with their build
|
||||
// contexts:
|
||||
//
|
||||
// | Build Syntax Suffix | Git reference used | Build Context Used |
|
||||
// |--------------------------------|----------------------|--------------------|
|
||||
// | my-repo.git | refs/heads/master | / |
|
||||
// | my-repo.git#mytag | refs/tags/my-tag | / |
|
||||
// | my-repo.git#mybranch | refs/heads/my-branch | / |
|
||||
// | my-repo.git#pull/42/head | refs/pull/42/head | / |
|
||||
// | my-repo.git#:directory | refs/heads/master | /directory |
|
||||
// | my-repo.git#master:directory | refs/heads/master | /directory |
|
||||
// | my-repo.git#mytag:directory | refs/tags/my-tag | /directory |
|
||||
// | my-repo.git#mybranch:directory | refs/heads/my-branch | /directory |
|
||||
func IsGitURL(str string) bool {
|
||||
if IsURL(str) && urlPathWithFragmentSuffix.MatchString(str) {
|
||||
return true
|
||||
}
|
||||
for _, prefix := range []string{"git://", "github.com/", "git@"} {
|
||||
if strings.HasPrefix(str, prefix) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
42
cli/command/image/build/internal/urlutil/urlutil_test.go
Normal file
42
cli/command/image/build/internal/urlutil/urlutil_test.go
Normal file
@ -0,0 +1,42 @@
|
||||
package urlutil
|
||||
|
||||
import "testing"
|
||||
|
||||
var (
|
||||
gitUrls = []string{
|
||||
"git://github.com/docker/docker",
|
||||
"git@github.com:docker/docker.git",
|
||||
"git@bitbucket.org:atlassianlabs/atlassian-docker.git",
|
||||
"https://github.com/docker/docker.git",
|
||||
"http://github.com/docker/docker.git",
|
||||
"http://github.com/docker/docker.git#branch",
|
||||
"http://github.com/docker/docker.git#:dir",
|
||||
}
|
||||
incompleteGitUrls = []string{
|
||||
"github.com/docker/docker",
|
||||
}
|
||||
invalidGitUrls = []string{
|
||||
"http://github.com/docker/docker.git:#branch",
|
||||
"https://github.com/docker/dgit",
|
||||
}
|
||||
)
|
||||
|
||||
func TestIsGIT(t *testing.T) {
|
||||
for _, url := range gitUrls {
|
||||
if !IsGitURL(url) {
|
||||
t.Fatalf("%q should be detected as valid Git url", url)
|
||||
}
|
||||
}
|
||||
|
||||
for _, url := range incompleteGitUrls {
|
||||
if !IsGitURL(url) {
|
||||
t.Fatalf("%q should be detected as valid Git url", url)
|
||||
}
|
||||
}
|
||||
|
||||
for _, url := range invalidGitUrls {
|
||||
if IsGitURL(url) {
|
||||
t.Fatalf("%q should not be detected as valid Git prefix", url)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user