FilesExpand file tree

 master

/

gitutils.go

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

100 lines (81 loc) · 2.39 KB

 master

/

gitutils.go

Copy path

Top

File metadata and controls

• Code
• Blame

100 lines (81 loc) · 2.39 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

package gitutils

import (

"fmt"

"io/ioutil"

"net/http"

"net/url"

"os"

"os/exec"

"path/filepath"

"strings"

"github.com/docker/docker/pkg/symlink"

"github.com/docker/docker/pkg/urlutil"

)

// Clone clones a repository into a newly created directory which

// will be under "docker-build-git"

func Clone(remoteURL string) (string, error) {

if !urlutil.IsGitTransport(remoteURL) {

remoteURL = "https://" + remoteURL

}

root, err := ioutil.TempDir("", "docker-build-git")

if err != nil {

return "", err

}

u, err := url.Parse(remoteURL)

if err != nil {

return "", err

}

fragment := u.Fragment

clone := cloneArgs(u, root)

if output, err := git(clone...); err != nil {

return "", fmt.Errorf("Error trying to use git: %s (%s)", err, output)

}

return checkoutGit(fragment, root)

}

func cloneArgs(remoteURL *url.URL, root string) []string {

args := []string{"clone", "--recursive"}

shallow := len(remoteURL.Fragment) == 0

if shallow && strings.HasPrefix(remoteURL.Scheme, "http") {

res, err := http.Head(fmt.Sprintf("%s/info/refs?service=git-upload-pack", remoteURL))

if err != nil || res.Header.Get("Content-Type") != "application/x-git-upload-pack-advertisement" {

shallow = false

}

}

if shallow {

args = append(args, "--depth", "1")

}

if remoteURL.Fragment != "" {

remoteURL.Fragment = ""

}

return append(args, remoteURL.String(), root)

}

func checkoutGit(fragment, root string) (string, error) {

refAndDir := strings.SplitN(fragment, ":", 2)

if len(refAndDir[0]) != 0 {

if output, err := gitWithinDir(root, "checkout", refAndDir[0]); err != nil {

return "", fmt.Errorf("Error trying to use git: %s (%s)", err, output)

}

}

if len(refAndDir) > 1 && len(refAndDir[1]) != 0 {

newCtx, err := symlink.FollowSymlinkInScope(filepath.Join(root, refAndDir[1]), root)

if err != nil {

return "", fmt.Errorf("Error setting git context, %q not within git root: %s", refAndDir[1], err)

}

fi, err := os.Stat(newCtx)

if err != nil {

return "", err

}

if !fi.IsDir() {

return "", fmt.Errorf("Error setting git context, not a directory: %s", newCtx)

}

root = newCtx

}

return root, nil

}

func gitWithinDir(dir string, args ...string) ([]byte, error) {

a := []string{"--work-tree", dir, "--git-dir", filepath.Join(dir, ".git")}

return git(append(a, args...)...)

}

func git(args ...string) ([]byte, error) {

return exec.Command("git", args...).CombinedOutput()

}