* monitor all git commands; move blame to git package and replace git as a variable * use git command but not other commands * fix build * move exec.Command to git.NewCommand * fix fmt * remove unrelated changes * remove unrelated changes * refactor IsEmpty and add tests * fix tests * fix tests * fix tests * fix tests * remove gitLogger * fix fmt * fix isEmpty * fix lint * fix teststags/v1.9.0-rc1
@@ -20,10 +20,13 @@ import ( | |||
"strconv" | |||
"time" | |||
"code.gitea.io/gitea/models" | |||
"code.gitea.io/gitea/modules/markup" | |||
"code.gitea.io/gitea/modules/markup/external" | |||
"code.gitea.io/gitea/modules/setting" | |||
"code.gitea.io/gitea/routers" | |||
"code.gitea.io/gitea/routers/routes" | |||
"github.com/Unknwon/com" | |||
"github.com/go-xorm/xorm" | |||
context2 "github.com/gorilla/context" | |||
@@ -31,9 +34,6 @@ import ( | |||
"gopkg.in/src-d/go-git.v4/config" | |||
"gopkg.in/src-d/go-git.v4/plumbing" | |||
"gopkg.in/testfixtures.v2" | |||
"code.gitea.io/gitea/models" | |||
"code.gitea.io/gitea/modules/setting" | |||
) | |||
var codeFilePath = "contrib/pr/checkout.go" |
@@ -675,7 +675,7 @@ func GetDiffRangeWithWhitespaceBehavior(repoPath, beforeCommitID, afterCommitID | |||
var cmd *exec.Cmd | |||
if len(beforeCommitID) == 0 && commit.ParentCount() == 0 { | |||
cmd = exec.Command("git", "show", afterCommitID) | |||
cmd = exec.Command(git.GitExecutable, "show", afterCommitID) | |||
} else { | |||
actualBeforeCommitID := beforeCommitID | |||
if len(actualBeforeCommitID) == 0 { | |||
@@ -688,7 +688,7 @@ func GetDiffRangeWithWhitespaceBehavior(repoPath, beforeCommitID, afterCommitID | |||
} | |||
diffArgs = append(diffArgs, actualBeforeCommitID) | |||
diffArgs = append(diffArgs, afterCommitID) | |||
cmd = exec.Command("git", diffArgs...) | |||
cmd = exec.Command(git.GitExecutable, diffArgs...) | |||
} | |||
cmd.Dir = repoPath | |||
cmd.Stderr = os.Stderr | |||
@@ -752,23 +752,23 @@ func GetRawDiffForFile(repoPath, startCommit, endCommit string, diffType RawDiff | |||
switch diffType { | |||
case RawDiffNormal: | |||
if len(startCommit) != 0 { | |||
cmd = exec.Command("git", append([]string{"diff", "-M", startCommit, endCommit}, fileArgs...)...) | |||
cmd = exec.Command(git.GitExecutable, append([]string{"diff", "-M", startCommit, endCommit}, fileArgs...)...) | |||
} else if commit.ParentCount() == 0 { | |||
cmd = exec.Command("git", append([]string{"show", endCommit}, fileArgs...)...) | |||
cmd = exec.Command(git.GitExecutable, append([]string{"show", endCommit}, fileArgs...)...) | |||
} else { | |||
c, _ := commit.Parent(0) | |||
cmd = exec.Command("git", append([]string{"diff", "-M", c.ID.String(), endCommit}, fileArgs...)...) | |||
cmd = exec.Command(git.GitExecutable, append([]string{"diff", "-M", c.ID.String(), endCommit}, fileArgs...)...) | |||
} | |||
case RawDiffPatch: | |||
if len(startCommit) != 0 { | |||
query := fmt.Sprintf("%s...%s", endCommit, startCommit) | |||
cmd = exec.Command("git", append([]string{"format-patch", "--no-signature", "--stdout", "--root", query}, fileArgs...)...) | |||
cmd = exec.Command(git.GitExecutable, append([]string{"format-patch", "--no-signature", "--stdout", "--root", query}, fileArgs...)...) | |||
} else if commit.ParentCount() == 0 { | |||
cmd = exec.Command("git", append([]string{"format-patch", "--no-signature", "--stdout", "--root", endCommit}, fileArgs...)...) | |||
cmd = exec.Command(git.GitExecutable, append([]string{"format-patch", "--no-signature", "--stdout", "--root", endCommit}, fileArgs...)...) | |||
} else { | |||
c, _ := commit.Parent(0) | |||
query := fmt.Sprintf("%s...%s", endCommit, c.ID.String()) | |||
cmd = exec.Command("git", append([]string{"format-patch", "--no-signature", "--stdout", query}, fileArgs...)...) | |||
cmd = exec.Command(git.GitExecutable, append([]string{"format-patch", "--no-signature", "--stdout", query}, fileArgs...)...) | |||
} | |||
default: | |||
return fmt.Errorf("invalid diffType: %s", diffType) |
@@ -463,7 +463,7 @@ func (pr *PullRequest) getMergeCommit() (*git.Commit, error) { | |||
// Check if a pull request is merged into BaseBranch | |||
_, stderr, err := process.GetManager().ExecDirEnv(-1, "", fmt.Sprintf("isMerged (git merge-base --is-ancestor): %d", pr.BaseRepo.ID), | |||
[]string{"GIT_INDEX_FILE=" + indexTmpPath, "GIT_DIR=" + pr.BaseRepo.RepoPath()}, | |||
"git", "merge-base", "--is-ancestor", headFile, pr.BaseBranch) | |||
git.GitExecutable, "merge-base", "--is-ancestor", headFile, pr.BaseBranch) | |||
if err != nil { | |||
// Errors are signaled by a non-zero status that is not 1 | |||
@@ -486,7 +486,7 @@ func (pr *PullRequest) getMergeCommit() (*git.Commit, error) { | |||
// Get the commit from BaseBranch where the pull request got merged | |||
mergeCommit, stderr, err := process.GetManager().ExecDirEnv(-1, "", fmt.Sprintf("isMerged (git rev-list --ancestry-path --merges --reverse): %d", pr.BaseRepo.ID), | |||
[]string{"GIT_INDEX_FILE=" + indexTmpPath, "GIT_DIR=" + pr.BaseRepo.RepoPath()}, | |||
"git", "rev-list", "--ancestry-path", "--merges", "--reverse", cmd) | |||
git.GitExecutable, "rev-list", "--ancestry-path", "--merges", "--reverse", cmd) | |||
if err != nil { | |||
return nil, fmt.Errorf("git rev-list --ancestry-path --merges --reverse: %v %v", stderr, err) | |||
} else if len(mergeCommit) < 40 { | |||
@@ -548,7 +548,7 @@ func (pr *PullRequest) testPatch(e Engine) (err error) { | |||
var stderr string | |||
_, stderr, err = process.GetManager().ExecDirEnv(-1, "", fmt.Sprintf("testPatch (git read-tree): %d", pr.BaseRepo.ID), | |||
[]string{"GIT_DIR=" + pr.BaseRepo.RepoPath(), "GIT_INDEX_FILE=" + indexTmpPath}, | |||
"git", "read-tree", pr.BaseBranch) | |||
git.GitExecutable, "read-tree", pr.BaseBranch) | |||
if err != nil { | |||
return fmt.Errorf("git read-tree --index-output=%s %s: %v - %s", indexTmpPath, pr.BaseBranch, err, stderr) | |||
} | |||
@@ -568,7 +568,7 @@ func (pr *PullRequest) testPatch(e Engine) (err error) { | |||
_, stderr, err = process.GetManager().ExecDirEnv(-1, "", fmt.Sprintf("testPatch (git apply --check): %d", pr.BaseRepo.ID), | |||
[]string{"GIT_INDEX_FILE=" + indexTmpPath, "GIT_DIR=" + pr.BaseRepo.RepoPath()}, | |||
"git", args...) | |||
git.GitExecutable, args...) | |||
if err != nil { | |||
for i := range patchConflicts { | |||
if strings.Contains(stderr, patchConflicts[i]) { |
@@ -434,7 +434,7 @@ func DeleteReleaseByID(id int64, u *User, delTag bool) error { | |||
if delTag { | |||
_, stderr, err := process.GetManager().ExecDir(-1, repo.RepoPath(), | |||
fmt.Sprintf("DeleteReleaseByID (git tag -d): %d", rel.ID), | |||
"git", "tag", "-d", rel.TagName) | |||
git.GitExecutable, "tag", "-d", rel.TagName) | |||
if err != nil && !strings.Contains(stderr, "not found") { | |||
return fmt.Errorf("git tag -d: %v - %s", err, stderr) | |||
} |
@@ -932,22 +932,18 @@ func MigrateRepository(doer, u *User, opts MigrateRepoOptions) (*Repository, err | |||
} | |||
} | |||
// Check if repository is empty. | |||
_, stderr, err := com.ExecCmdDir(repoPath, "git", "log", "-1") | |||
gitRepo, err := git.OpenRepository(repoPath) | |||
if err != nil { | |||
if strings.Contains(stderr, "fatal: bad default revision 'HEAD'") { | |||
repo.IsEmpty = true | |||
} else { | |||
return repo, fmt.Errorf("check empty: %v - %s", err, stderr) | |||
} | |||
return repo, fmt.Errorf("OpenRepository: %v", err) | |||
} | |||
repo.IsEmpty, err = gitRepo.IsEmpty() | |||
if err != nil { | |||
return repo, fmt.Errorf("git.IsEmpty: %v", err) | |||
} | |||
if !repo.IsEmpty { | |||
// Try to get HEAD branch and set it as default branch. | |||
gitRepo, err := git.OpenRepository(repoPath) | |||
if err != nil { | |||
return repo, fmt.Errorf("OpenRepository: %v", err) | |||
} | |||
headBranch, err := gitRepo.GetHEADBranch() | |||
if err != nil { | |||
return repo, fmt.Errorf("GetHEADBranch: %v", err) | |||
@@ -1072,20 +1068,20 @@ func initRepoCommit(tmpPath string, sig *git.Signature) (err error) { | |||
var stderr string | |||
if _, stderr, err = process.GetManager().ExecDir(-1, | |||
tmpPath, fmt.Sprintf("initRepoCommit (git add): %s", tmpPath), | |||
"git", "add", "--all"); err != nil { | |||
git.GitExecutable, "add", "--all"); err != nil { | |||
return fmt.Errorf("git add: %s", stderr) | |||
} | |||
if _, stderr, err = process.GetManager().ExecDir(-1, | |||
tmpPath, fmt.Sprintf("initRepoCommit (git commit): %s", tmpPath), | |||
"git", "commit", fmt.Sprintf("--author='%s <%s>'", sig.Name, sig.Email), | |||
git.GitExecutable, "commit", fmt.Sprintf("--author='%s <%s>'", sig.Name, sig.Email), | |||
"-m", "Initial commit"); err != nil { | |||
return fmt.Errorf("git commit: %s", stderr) | |||
} | |||
if _, stderr, err = process.GetManager().ExecDir(-1, | |||
tmpPath, fmt.Sprintf("initRepoCommit (git push): %s", tmpPath), | |||
"git", "push", "origin", "master"); err != nil { | |||
git.GitExecutable, "push", "origin", "master"); err != nil { | |||
return fmt.Errorf("git push: %s", stderr) | |||
} | |||
return nil | |||
@@ -1131,7 +1127,7 @@ func prepareRepoCommit(e Engine, repo *Repository, tmpDir, repoPath string, opts | |||
// Clone to temporary path and do the init commit. | |||
_, stderr, err := process.GetManager().Exec( | |||
fmt.Sprintf("initRepository(git clone): %s", repoPath), | |||
"git", "clone", repoPath, tmpDir, | |||
git.GitExecutable, "clone", repoPath, tmpDir, | |||
) | |||
if err != nil { | |||
return fmt.Errorf("git clone: %v - %s", err, stderr) | |||
@@ -1390,7 +1386,7 @@ func CreateRepository(doer, u *User, opts CreateRepoOptions) (_ *Repository, err | |||
_, stderr, err := process.GetManager().ExecDir(-1, | |||
repoPath, fmt.Sprintf("CreateRepository(git update-server-info): %s", repoPath), | |||
"git", "update-server-info") | |||
git.GitExecutable, "update-server-info") | |||
if err != nil { | |||
return nil, errors.New("CreateRepository(git update-server-info): " + stderr) | |||
} | |||
@@ -2239,7 +2235,7 @@ func GitGcRepos() error { | |||
_, stderr, err := process.GetManager().ExecDir( | |||
time.Duration(setting.Git.Timeout.GC)*time.Second, | |||
RepoPath(repo.Owner.Name, repo.Name), "Repository garbage collection", | |||
"git", args...) | |||
git.GitExecutable, args...) | |||
if err != nil { | |||
return fmt.Errorf("%v: %v", err, stderr) | |||
} | |||
@@ -2429,14 +2425,14 @@ func ForkRepository(doer, u *User, oldRepo *Repository, name, desc string) (_ *R | |||
repoPath := RepoPath(u.Name, repo.Name) | |||
_, stderr, err := process.GetManager().ExecTimeout(10*time.Minute, | |||
fmt.Sprintf("ForkRepository(git clone): %s/%s", u.Name, repo.Name), | |||
"git", "clone", "--bare", oldRepo.repoPath(sess), repoPath) | |||
git.GitExecutable, "clone", "--bare", oldRepo.repoPath(sess), repoPath) | |||
if err != nil { | |||
return nil, fmt.Errorf("git clone: %v", stderr) | |||
} | |||
_, stderr, err = process.GetManager().ExecDir(-1, | |||
repoPath, fmt.Sprintf("ForkRepository(git update-server-info): %s", repoPath), | |||
"git", "update-server-info") | |||
git.GitExecutable, "update-server-info") | |||
if err != nil { | |||
return nil, fmt.Errorf("git update-server-info: %v", stderr) | |||
} |
@@ -216,7 +216,7 @@ func (m *Mirror) runSync() ([]*mirrorSyncResult, bool) { | |||
_, stderr, err := process.GetManager().ExecDir( | |||
timeout, repoPath, fmt.Sprintf("Mirror.runSync: %s", repoPath), | |||
"git", gitArgs...) | |||
git.GitExecutable, gitArgs...) | |||
if err != nil { | |||
// sanitize the output, since it may contain the remote address, which may | |||
// contain a password | |||
@@ -250,7 +250,7 @@ func (m *Mirror) runSync() ([]*mirrorSyncResult, bool) { | |||
if m.Repo.HasWiki() { | |||
if _, stderr, err := process.GetManager().ExecDir( | |||
timeout, wikiPath, fmt.Sprintf("Mirror.runSync: %s", wikiPath), | |||
"git", "remote", "update", "--prune"); err != nil { | |||
git.GitExecutable, "remote", "update", "--prune"); err != nil { | |||
// sanitize the output, since it may contain the remote address, which may | |||
// contain a password | |||
message, err := sanitizeOutput(stderr, wikiPath) |
@@ -7,7 +7,6 @@ package models | |||
import ( | |||
"container/list" | |||
"fmt" | |||
"os/exec" | |||
"strings" | |||
"time" | |||
@@ -193,9 +192,8 @@ func pushUpdate(opts PushUpdateOptions) (repo *Repository, err error) { | |||
repoPath := RepoPath(opts.RepoUserName, opts.RepoName) | |||
gitUpdate := exec.Command("git", "update-server-info") | |||
gitUpdate.Dir = repoPath | |||
if err = gitUpdate.Run(); err != nil { | |||
_, err = git.NewCommand("update-server-info").RunInDir(repoPath) | |||
if err != nil { | |||
return nil, fmt.Errorf("Failed to call 'git update-server-info': %v", err) | |||
} | |||
@@ -2,7 +2,7 @@ | |||
// Use of this source code is governed by a MIT-style | |||
// license that can be found in the LICENSE file. | |||
package models | |||
package git | |||
import ( | |||
"bufio" | |||
@@ -12,7 +12,6 @@ import ( | |||
"os/exec" | |||
"regexp" | |||
"code.gitea.io/gitea/modules/git" | |||
"code.gitea.io/gitea/modules/process" | |||
) | |||
@@ -88,12 +87,12 @@ func (r *BlameReader) Close() error { | |||
// CreateBlameReader creates reader for given repository, commit and file | |||
func CreateBlameReader(repoPath, commitID, file string) (*BlameReader, error) { | |||
_, err := git.OpenRepository(repoPath) | |||
_, err := OpenRepository(repoPath) | |||
if err != nil { | |||
return nil, err | |||
} | |||
return createBlameReader(repoPath, "git", "blame", commitID, "--porcelain", "--", file) | |||
return createBlameReader(repoPath, GitExecutable, "blame", commitID, "--porcelain", "--", file) | |||
} | |||
func createBlameReader(dir string, command ...string) (*BlameReader, error) { |
@@ -2,7 +2,7 @@ | |||
// Use of this source code is governed by a MIT-style | |||
// license that can be found in the LICENSE file. | |||
package models | |||
package git | |||
import ( | |||
"io/ioutil" |
@@ -12,6 +12,8 @@ import ( | |||
"os/exec" | |||
"strings" | |||
"time" | |||
"code.gitea.io/gitea/modules/process" | |||
) | |||
var ( | |||
@@ -84,6 +86,9 @@ func (c *Command) RunInDirTimeoutEnvFullPipeline(env []string, timeout time.Dura | |||
return err | |||
} | |||
pid := process.GetManager().Add(fmt.Sprintf("%s %s %s [repo_path: %s]", GitExecutable, c.name, strings.Join(c.args, " "), dir), cmd) | |||
defer process.GetManager().Remove(pid) | |||
if err := cmd.Wait(); err != nil { | |||
return err | |||
} |
@@ -107,6 +107,20 @@ func OpenRepository(repoPath string) (*Repository, error) { | |||
}, nil | |||
} | |||
// IsEmpty Check if repository is empty. | |||
func (repo *Repository) IsEmpty() (bool, error) { | |||
var errbuf strings.Builder | |||
if err := NewCommand("log", "-1").RunInDirPipeline(repo.Path, nil, &errbuf); err != nil { | |||
if strings.Contains(errbuf.String(), "fatal: bad default revision 'HEAD'") || | |||
strings.Contains(errbuf.String(), "fatal: your current branch 'master' does not have any commits yet") { | |||
return true, nil | |||
} | |||
return true, fmt.Errorf("check empty: %v - %s", err, errbuf.String()) | |||
} | |||
return false, nil | |||
} | |||
// CloneRepoOptions options when clone a repository | |||
type CloneRepoOptions struct { | |||
Timeout time.Duration |
@@ -5,6 +5,7 @@ | |||
package git | |||
import ( | |||
"path/filepath" | |||
"testing" | |||
"time" | |||
@@ -24,3 +25,12 @@ func TestGetLatestCommitTime(t *testing.T) { | |||
assert.NoError(t, err) | |||
assert.True(t, lct.Unix() > refTime.Unix(), "%d not greater than %d", lct, refTime) | |||
} | |||
func TestRepoIsEmpty(t *testing.T) { | |||
emptyRepo2Path := filepath.Join(testReposDir, "repo2_empty") | |||
repo, err := OpenRepository(emptyRepo2Path) | |||
assert.NoError(t, err) | |||
isEmpty, err := repo.IsEmpty() | |||
assert.NoError(t, err) | |||
assert.True(t, isEmpty) | |||
} |
@@ -0,0 +1 @@ | |||
ref: refs/heads/master |
@@ -0,0 +1,6 @@ | |||
[core] | |||
repositoryformatversion = 0 | |||
filemode = true | |||
bare = true | |||
ignorecase = true | |||
precomposeunicode = true |
@@ -0,0 +1 @@ | |||
Unnamed repository; edit this file 'description' to name the repository. |
@@ -0,0 +1,15 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to check the commit log message taken by | |||
# applypatch from an e-mail message. | |||
# | |||
# The hook should exit with non-zero status after issuing an | |||
# appropriate message if it wants to stop the commit. The hook is | |||
# allowed to edit the commit message file. | |||
# | |||
# To enable this hook, rename this file to "applypatch-msg". | |||
. git-sh-setup | |||
commitmsg="$(git rev-parse --git-path hooks/commit-msg)" | |||
test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"} | |||
: |
@@ -0,0 +1,24 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to check the commit log message. | |||
# Called by "git commit" with one argument, the name of the file | |||
# that has the commit message. The hook should exit with non-zero | |||
# status after issuing an appropriate message if it wants to stop the | |||
# commit. The hook is allowed to edit the commit message file. | |||
# | |||
# To enable this hook, rename this file to "commit-msg". | |||
# Uncomment the below to add a Signed-off-by line to the message. | |||
# Doing this in a hook is a bad idea in general, but the prepare-commit-msg | |||
# hook is more suited to it. | |||
# | |||
# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') | |||
# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" | |||
# This example catches duplicate Signed-off-by lines. | |||
test "" = "$(grep '^Signed-off-by: ' "$1" | | |||
sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { | |||
echo >&2 Duplicate Signed-off-by lines. | |||
exit 1 | |||
} |
@@ -0,0 +1,114 @@ | |||
#!/usr/bin/perl | |||
use strict; | |||
use warnings; | |||
use IPC::Open2; | |||
# An example hook script to integrate Watchman | |||
# (https://facebook.github.io/watchman/) with git to speed up detecting | |||
# new and modified files. | |||
# | |||
# The hook is passed a version (currently 1) and a time in nanoseconds | |||
# formatted as a string and outputs to stdout all files that have been | |||
# modified since the given time. Paths must be relative to the root of | |||
# the working tree and separated by a single NUL. | |||
# | |||
# To enable this hook, rename this file to "query-watchman" and set | |||
# 'git config core.fsmonitor .git/hooks/query-watchman' | |||
# | |||
my ($version, $time) = @ARGV; | |||
# Check the hook interface version | |||
if ($version == 1) { | |||
# convert nanoseconds to seconds | |||
$time = int $time / 1000000000; | |||
} else { | |||
die "Unsupported query-fsmonitor hook version '$version'.\n" . | |||
"Falling back to scanning...\n"; | |||
} | |||
my $git_work_tree; | |||
if ($^O =~ 'msys' || $^O =~ 'cygwin') { | |||
$git_work_tree = Win32::GetCwd(); | |||
$git_work_tree =~ tr/\\/\//; | |||
} else { | |||
require Cwd; | |||
$git_work_tree = Cwd::cwd(); | |||
} | |||
my $retry = 1; | |||
launch_watchman(); | |||
sub launch_watchman { | |||
my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty') | |||
or die "open2() failed: $!\n" . | |||
"Falling back to scanning...\n"; | |||
# In the query expression below we're asking for names of files that | |||
# changed since $time but were not transient (ie created after | |||
# $time but no longer exist). | |||
# | |||
# To accomplish this, we're using the "since" generator to use the | |||
# recency index to select candidate nodes and "fields" to limit the | |||
# output to file names only. Then we're using the "expression" term to | |||
# further constrain the results. | |||
# | |||
# The category of transient files that we want to ignore will have a | |||
# creation clock (cclock) newer than $time_t value and will also not | |||
# currently exist. | |||
my $query = <<" END"; | |||
["query", "$git_work_tree", { | |||
"since": $time, | |||
"fields": ["name"], | |||
"expression": ["not", ["allof", ["since", $time, "cclock"], ["not", "exists"]]] | |||
}] | |||
END | |||
print CHLD_IN $query; | |||
close CHLD_IN; | |||
my $response = do {local $/; <CHLD_OUT>}; | |||
die "Watchman: command returned no output.\n" . | |||
"Falling back to scanning...\n" if $response eq ""; | |||
die "Watchman: command returned invalid output: $response\n" . | |||
"Falling back to scanning...\n" unless $response =~ /^\{/; | |||
my $json_pkg; | |||
eval { | |||
require JSON::XS; | |||
$json_pkg = "JSON::XS"; | |||
1; | |||
} or do { | |||
require JSON::PP; | |||
$json_pkg = "JSON::PP"; | |||
}; | |||
my $o = $json_pkg->new->utf8->decode($response); | |||
if ($retry > 0 and $o->{error} and $o->{error} =~ m/unable to resolve root .* directory (.*) is not watched/) { | |||
print STDERR "Adding '$git_work_tree' to watchman's watch list.\n"; | |||
$retry--; | |||
qx/watchman watch "$git_work_tree"/; | |||
die "Failed to make watchman watch '$git_work_tree'.\n" . | |||
"Falling back to scanning...\n" if $? != 0; | |||
# Watchman will always return all files on the first query so | |||
# return the fast "everything is dirty" flag to git and do the | |||
# Watchman query just to get it over with now so we won't pay | |||
# the cost in git to look up each individual file. | |||
print "/\0"; | |||
eval { launch_watchman() }; | |||
exit 0; | |||
} | |||
die "Watchman: $o->{error}.\n" . | |||
"Falling back to scanning...\n" if $o->{error}; | |||
binmode STDOUT, ":utf8"; | |||
local $, = "\0"; | |||
print @{$o->{files}}; | |||
} |
@@ -0,0 +1,8 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to prepare a packed repository for use over | |||
# dumb transports. | |||
# | |||
# To enable this hook, rename this file to "post-update". | |||
exec git update-server-info |
@@ -0,0 +1,14 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to verify what is about to be committed | |||
# by applypatch from an e-mail message. | |||
# | |||
# The hook should exit with non-zero status after issuing an | |||
# appropriate message if it wants to stop the commit. | |||
# | |||
# To enable this hook, rename this file to "pre-applypatch". | |||
. git-sh-setup | |||
precommit="$(git rev-parse --git-path hooks/pre-commit)" | |||
test -x "$precommit" && exec "$precommit" ${1+"$@"} | |||
: |
@@ -0,0 +1,49 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to verify what is about to be committed. | |||
# Called by "git commit" with no arguments. The hook should | |||
# exit with non-zero status after issuing an appropriate message if | |||
# it wants to stop the commit. | |||
# | |||
# To enable this hook, rename this file to "pre-commit". | |||
if git rev-parse --verify HEAD >/dev/null 2>&1 | |||
then | |||
against=HEAD | |||
else | |||
# Initial commit: diff against an empty tree object | |||
against=$(git hash-object -t tree /dev/null) | |||
fi | |||
# If you want to allow non-ASCII filenames set this variable to true. | |||
allownonascii=$(git config --bool hooks.allownonascii) | |||
# Redirect output to stderr. | |||
exec 1>&2 | |||
# Cross platform projects tend to avoid non-ASCII filenames; prevent | |||
# them from being added to the repository. We exploit the fact that the | |||
# printable range starts at the space character and ends with tilde. | |||
if [ "$allownonascii" != "true" ] && | |||
# Note that the use of brackets around a tr range is ok here, (it's | |||
# even required, for portability to Solaris 10's /usr/bin/tr), since | |||
# the square bracket bytes happen to fall in the designated range. | |||
test $(git diff --cached --name-only --diff-filter=A -z $against | | |||
LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 | |||
then | |||
cat <<\EOF | |||
Error: Attempt to add a non-ASCII file name. | |||
This can cause problems if you want to work with people on other platforms. | |||
To be portable it is advisable to rename the file. | |||
If you know what you are doing you can disable this check using: | |||
git config hooks.allownonascii true | |||
EOF | |||
exit 1 | |||
fi | |||
# If there are whitespace errors, print the offending file names and fail. | |||
exec git diff-index --check --cached $against -- |
@@ -0,0 +1,53 @@ | |||
#!/bin/sh | |||
# An example hook script to verify what is about to be pushed. Called by "git | |||
# push" after it has checked the remote status, but before anything has been | |||
# pushed. If this script exits with a non-zero status nothing will be pushed. | |||
# | |||
# This hook is called with the following parameters: | |||
# | |||
# $1 -- Name of the remote to which the push is being done | |||
# $2 -- URL to which the push is being done | |||
# | |||
# If pushing without using a named remote those arguments will be equal. | |||
# | |||
# Information about the commits which are being pushed is supplied as lines to | |||
# the standard input in the form: | |||
# | |||
# <local ref> <local sha1> <remote ref> <remote sha1> | |||
# | |||
# This sample shows how to prevent push of commits where the log message starts | |||
# with "WIP" (work in progress). | |||
remote="$1" | |||
url="$2" | |||
z40=0000000000000000000000000000000000000000 | |||
while read local_ref local_sha remote_ref remote_sha | |||
do | |||
if [ "$local_sha" = $z40 ] | |||
then | |||
# Handle delete | |||
: | |||
else | |||
if [ "$remote_sha" = $z40 ] | |||
then | |||
# New branch, examine all commits | |||
range="$local_sha" | |||
else | |||
# Update to existing branch, examine new commits | |||
range="$remote_sha..$local_sha" | |||
fi | |||
# Check for WIP commit | |||
commit=`git rev-list -n 1 --grep '^WIP' "$range"` | |||
if [ -n "$commit" ] | |||
then | |||
echo >&2 "Found WIP commit in $local_ref, not pushing" | |||
exit 1 | |||
fi | |||
fi | |||
done | |||
exit 0 |
@@ -0,0 +1,169 @@ | |||
#!/bin/sh | |||
# | |||
# Copyright (c) 2006, 2008 Junio C Hamano | |||
# | |||
# The "pre-rebase" hook is run just before "git rebase" starts doing | |||
# its job, and can prevent the command from running by exiting with | |||
# non-zero status. | |||
# | |||
# The hook is called with the following parameters: | |||
# | |||
# $1 -- the upstream the series was forked from. | |||
# $2 -- the branch being rebased (or empty when rebasing the current branch). | |||
# | |||
# This sample shows how to prevent topic branches that are already | |||
# merged to 'next' branch from getting rebased, because allowing it | |||
# would result in rebasing already published history. | |||
publish=next | |||
basebranch="$1" | |||
if test "$#" = 2 | |||
then | |||
topic="refs/heads/$2" | |||
else | |||
topic=`git symbolic-ref HEAD` || | |||
exit 0 ;# we do not interrupt rebasing detached HEAD | |||
fi | |||
case "$topic" in | |||
refs/heads/??/*) | |||
;; | |||
*) | |||
exit 0 ;# we do not interrupt others. | |||
;; | |||
esac | |||
# Now we are dealing with a topic branch being rebased | |||
# on top of master. Is it OK to rebase it? | |||
# Does the topic really exist? | |||
git show-ref -q "$topic" || { | |||
echo >&2 "No such branch $topic" | |||
exit 1 | |||
} | |||
# Is topic fully merged to master? | |||
not_in_master=`git rev-list --pretty=oneline ^master "$topic"` | |||
if test -z "$not_in_master" | |||
then | |||
echo >&2 "$topic is fully merged to master; better remove it." | |||
exit 1 ;# we could allow it, but there is no point. | |||
fi | |||
# Is topic ever merged to next? If so you should not be rebasing it. | |||
only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` | |||
only_next_2=`git rev-list ^master ${publish} | sort` | |||
if test "$only_next_1" = "$only_next_2" | |||
then | |||
not_in_topic=`git rev-list "^$topic" master` | |||
if test -z "$not_in_topic" | |||
then | |||
echo >&2 "$topic is already up to date with master" | |||
exit 1 ;# we could allow it, but there is no point. | |||
else | |||
exit 0 | |||
fi | |||
else | |||
not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` | |||
/usr/bin/perl -e ' | |||
my $topic = $ARGV[0]; | |||
my $msg = "* $topic has commits already merged to public branch:\n"; | |||
my (%not_in_next) = map { | |||
/^([0-9a-f]+) /; | |||
($1 => 1); | |||
} split(/\n/, $ARGV[1]); | |||
for my $elem (map { | |||
/^([0-9a-f]+) (.*)$/; | |||
[$1 => $2]; | |||
} split(/\n/, $ARGV[2])) { | |||
if (!exists $not_in_next{$elem->[0]}) { | |||
if ($msg) { | |||
print STDERR $msg; | |||
undef $msg; | |||
} | |||
print STDERR " $elem->[1]\n"; | |||
} | |||
} | |||
' "$topic" "$not_in_next" "$not_in_master" | |||
exit 1 | |||
fi | |||
<<\DOC_END | |||
This sample hook safeguards topic branches that have been | |||
published from being rewound. | |||
The workflow assumed here is: | |||
* Once a topic branch forks from "master", "master" is never | |||
merged into it again (either directly or indirectly). | |||
* Once a topic branch is fully cooked and merged into "master", | |||
it is deleted. If you need to build on top of it to correct | |||
earlier mistakes, a new topic branch is created by forking at | |||
the tip of the "master". This is not strictly necessary, but | |||
it makes it easier to keep your history simple. | |||
* Whenever you need to test or publish your changes to topic | |||
branches, merge them into "next" branch. | |||
The script, being an example, hardcodes the publish branch name | |||
to be "next", but it is trivial to make it configurable via | |||
$GIT_DIR/config mechanism. | |||
With this workflow, you would want to know: | |||
(1) ... if a topic branch has ever been merged to "next". Young | |||
topic branches can have stupid mistakes you would rather | |||
clean up before publishing, and things that have not been | |||
merged into other branches can be easily rebased without | |||
affecting other people. But once it is published, you would | |||
not want to rewind it. | |||
(2) ... if a topic branch has been fully merged to "master". | |||
Then you can delete it. More importantly, you should not | |||
build on top of it -- other people may already want to | |||
change things related to the topic as patches against your | |||
"master", so if you need further changes, it is better to | |||
fork the topic (perhaps with the same name) afresh from the | |||
tip of "master". | |||
Let's look at this example: | |||
o---o---o---o---o---o---o---o---o---o "next" | |||
/ / / / | |||
/ a---a---b A / / | |||
/ / / / | |||
/ / c---c---c---c B / | |||
/ / / \ / | |||
/ / / b---b C \ / | |||
/ / / / \ / | |||
---o---o---o---o---o---o---o---o---o---o---o "master" | |||
A, B and C are topic branches. | |||
* A has one fix since it was merged up to "next". | |||
* B has finished. It has been fully merged up to "master" and "next", | |||
and is ready to be deleted. | |||
* C has not merged to "next" at all. | |||
We would want to allow C to be rebased, refuse A, and encourage | |||
B to be deleted. | |||
To compute (1): | |||
git rev-list ^master ^topic next | |||
git rev-list ^master next | |||
if these match, topic has not merged in next at all. | |||
To compute (2): | |||
git rev-list master..topic | |||
if this is empty, it is fully merged to "master". | |||
DOC_END |
@@ -0,0 +1,24 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to make use of push options. | |||
# The example simply echoes all push options that start with 'echoback=' | |||
# and rejects all pushes when the "reject" push option is used. | |||
# | |||
# To enable this hook, rename this file to "pre-receive". | |||
if test -n "$GIT_PUSH_OPTION_COUNT" | |||
then | |||
i=0 | |||
while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" | |||
do | |||
eval "value=\$GIT_PUSH_OPTION_$i" | |||
case "$value" in | |||
echoback=*) | |||
echo "echo from the pre-receive-hook: ${value#*=}" >&2 | |||
;; | |||
reject) | |||
exit 1 | |||
esac | |||
i=$((i + 1)) | |||
done | |||
fi |
@@ -0,0 +1,42 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to prepare the commit log message. | |||
# Called by "git commit" with the name of the file that has the | |||
# commit message, followed by the description of the commit | |||
# message's source. The hook's purpose is to edit the commit | |||
# message file. If the hook fails with a non-zero status, | |||
# the commit is aborted. | |||
# | |||
# To enable this hook, rename this file to "prepare-commit-msg". | |||
# This hook includes three examples. The first one removes the | |||
# "# Please enter the commit message..." help message. | |||
# | |||
# The second includes the output of "git diff --name-status -r" | |||
# into the message, just before the "git status" output. It is | |||
# commented because it doesn't cope with --amend or with squashed | |||
# commits. | |||
# | |||
# The third example adds a Signed-off-by line to the message, that can | |||
# still be edited. This is rarely a good idea. | |||
COMMIT_MSG_FILE=$1 | |||
COMMIT_SOURCE=$2 | |||
SHA1=$3 | |||
/usr/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE" | |||
# case "$COMMIT_SOURCE,$SHA1" in | |||
# ,|template,) | |||
# /usr/bin/perl -i.bak -pe ' | |||
# print "\n" . `git diff --cached --name-status -r` | |||
# if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;; | |||
# *) ;; | |||
# esac | |||
# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') | |||
# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE" | |||
# if test -z "$COMMIT_SOURCE" | |||
# then | |||
# /usr/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE" | |||
# fi |
@@ -0,0 +1,128 @@ | |||
#!/bin/sh | |||
# | |||
# An example hook script to block unannotated tags from entering. | |||
# Called by "git receive-pack" with arguments: refname sha1-old sha1-new | |||
# | |||
# To enable this hook, rename this file to "update". | |||
# | |||
# Config | |||
# ------ | |||
# hooks.allowunannotated | |||
# This boolean sets whether unannotated tags will be allowed into the | |||
# repository. By default they won't be. | |||
# hooks.allowdeletetag | |||
# This boolean sets whether deleting tags will be allowed in the | |||
# repository. By default they won't be. | |||
# hooks.allowmodifytag | |||
# This boolean sets whether a tag may be modified after creation. By default | |||
# it won't be. | |||
# hooks.allowdeletebranch | |||
# This boolean sets whether deleting branches will be allowed in the | |||
# repository. By default they won't be. | |||
# hooks.denycreatebranch | |||
# This boolean sets whether remotely creating branches will be denied | |||
# in the repository. By default this is allowed. | |||
# | |||
# --- Command line | |||
refname="$1" | |||
oldrev="$2" | |||
newrev="$3" | |||
# --- Safety check | |||
if [ -z "$GIT_DIR" ]; then | |||
echo "Don't run this script from the command line." >&2 | |||
echo " (if you want, you could supply GIT_DIR then run" >&2 | |||
echo " $0 <ref> <oldrev> <newrev>)" >&2 | |||
exit 1 | |||
fi | |||
if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then | |||
echo "usage: $0 <ref> <oldrev> <newrev>" >&2 | |||
exit 1 | |||
fi | |||
# --- Config | |||
allowunannotated=$(git config --bool hooks.allowunannotated) | |||
allowdeletebranch=$(git config --bool hooks.allowdeletebranch) | |||
denycreatebranch=$(git config --bool hooks.denycreatebranch) | |||
allowdeletetag=$(git config --bool hooks.allowdeletetag) | |||
allowmodifytag=$(git config --bool hooks.allowmodifytag) | |||
# check for no description | |||
projectdesc=$(sed -e '1q' "$GIT_DIR/description") | |||
case "$projectdesc" in | |||
"Unnamed repository"* | "") | |||
echo "*** Project description file hasn't been set" >&2 | |||
exit 1 | |||
;; | |||
esac | |||
# --- Check types | |||
# if $newrev is 0000...0000, it's a commit to delete a ref. | |||
zero="0000000000000000000000000000000000000000" | |||
if [ "$newrev" = "$zero" ]; then | |||
newrev_type=delete | |||
else | |||
newrev_type=$(git cat-file -t $newrev) | |||
fi | |||
case "$refname","$newrev_type" in | |||
refs/tags/*,commit) | |||
# un-annotated tag | |||
short_refname=${refname##refs/tags/} | |||
if [ "$allowunannotated" != "true" ]; then | |||
echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2 | |||
echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 | |||
exit 1 | |||
fi | |||
;; | |||
refs/tags/*,delete) | |||
# delete tag | |||
if [ "$allowdeletetag" != "true" ]; then | |||
echo "*** Deleting a tag is not allowed in this repository" >&2 | |||
exit 1 | |||
fi | |||
;; | |||
refs/tags/*,tag) | |||
# annotated tag | |||
if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 | |||
then | |||
echo "*** Tag '$refname' already exists." >&2 | |||
echo "*** Modifying a tag is not allowed in this repository." >&2 | |||
exit 1 | |||
fi | |||
;; | |||
refs/heads/*,commit) | |||
# branch | |||
if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then | |||
echo "*** Creating a branch is not allowed in this repository" >&2 | |||
exit 1 | |||
fi | |||
;; | |||
refs/heads/*,delete) | |||
# delete branch | |||
if [ "$allowdeletebranch" != "true" ]; then | |||
echo "*** Deleting a branch is not allowed in this repository" >&2 | |||
exit 1 | |||
fi | |||
;; | |||
refs/remotes/*,commit) | |||
# tracking branch | |||
;; | |||
refs/remotes/*,delete) | |||
# delete tracking branch | |||
if [ "$allowdeletebranch" != "true" ]; then | |||
echo "*** Deleting a tracking branch is not allowed in this repository" >&2 | |||
exit 1 | |||
fi | |||
;; | |||
*) | |||
# Anything else (is there anything else?) | |||
echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 | |||
exit 1 | |||
;; | |||
esac | |||
# --- Finished | |||
exit 0 |
@@ -0,0 +1,6 @@ | |||
# git ls-files --others --exclude-from=.git/info/exclude | |||
# Lines that start with '#' are comments. | |||
# For a project mostly in C, the following would be a good set of | |||
# exclude patterns (uncomment them if you want to use them): | |||
# *.[oa] | |||
# *~ |
@@ -50,7 +50,7 @@ func (t *TemporaryUploadRepository) Close() { | |||
func (t *TemporaryUploadRepository) Clone(branch string) error { | |||
if _, stderr, err := process.GetManager().ExecTimeout(5*time.Minute, | |||
fmt.Sprintf("Clone (git clone -s --bare): %s", t.basePath), | |||
"git", "clone", "-s", "--bare", "-b", branch, t.repo.RepoPath(), t.basePath); err != nil { | |||
git.GitExecutable, "clone", "-s", "--bare", "-b", branch, t.repo.RepoPath(), t.basePath); err != nil { | |||
if matched, _ := regexp.MatchString(".*Remote branch .* not found in upstream origin.*", stderr); matched { | |||
return git.ErrBranchNotExist{ | |||
Name: branch, | |||
@@ -79,7 +79,7 @@ func (t *TemporaryUploadRepository) SetDefaultIndex() error { | |||
if _, stderr, err := process.GetManager().ExecDir(5*time.Minute, | |||
t.basePath, | |||
fmt.Sprintf("SetDefaultIndex (git read-tree HEAD): %s", t.basePath), | |||
"git", "read-tree", "HEAD"); err != nil { | |||
git.GitExecutable, "read-tree", "HEAD"); err != nil { | |||
return fmt.Errorf("SetDefaultIndex: %v %s", err, stderr) | |||
} | |||
return nil | |||
@@ -101,7 +101,7 @@ func (t *TemporaryUploadRepository) LsFiles(filenames ...string) ([]string, erro | |||
} | |||
} | |||
cmd := exec.CommandContext(ctx, "git", cmdArgs...) | |||
cmd := exec.CommandContext(ctx, git.GitExecutable, cmdArgs...) | |||
desc := fmt.Sprintf("lsFiles: (git ls-files) %v", cmdArgs) | |||
cmd.Dir = t.basePath | |||
cmd.Stdout = stdOut | |||
@@ -146,7 +146,7 @@ func (t *TemporaryUploadRepository) RemoveFilesFromIndex(filenames ...string) er | |||
defer cancel() | |||
cmdArgs := []string{"update-index", "--remove", "-z", "--index-info"} | |||
cmd := exec.CommandContext(ctx, "git", cmdArgs...) | |||
cmd := exec.CommandContext(ctx, git.GitExecutable, cmdArgs...) | |||
desc := fmt.Sprintf("removeFilesFromIndex: (git update-index) %v", filenames) | |||
cmd.Dir = t.basePath | |||
cmd.Stdout = stdOut | |||
@@ -174,7 +174,7 @@ func (t *TemporaryUploadRepository) HashObject(content io.Reader) (string, error | |||
ctx, cancel := context.WithTimeout(context.Background(), timeout) | |||
defer cancel() | |||
hashCmd := exec.CommandContext(ctx, "git", "hash-object", "-w", "--stdin") | |||
hashCmd := exec.CommandContext(ctx, git.GitExecutable, "hash-object", "-w", "--stdin") | |||
hashCmd.Dir = t.basePath | |||
hashCmd.Stdin = content | |||
stdOutBuffer := new(bytes.Buffer) | |||
@@ -203,7 +203,7 @@ func (t *TemporaryUploadRepository) AddObjectToIndex(mode, objectHash, objectPat | |||
if _, stderr, err := process.GetManager().ExecDir(5*time.Minute, | |||
t.basePath, | |||
fmt.Sprintf("addObjectToIndex (git update-index): %s", t.basePath), | |||
"git", "update-index", "--add", "--replace", "--cacheinfo", mode, objectHash, objectPath); err != nil { | |||
git.GitExecutable, "update-index", "--add", "--replace", "--cacheinfo", mode, objectHash, objectPath); err != nil { | |||
if matched, _ := regexp.MatchString(".*Invalid path '.*", stderr); matched { | |||
return models.ErrFilePathInvalid{ | |||
Message: objectPath, | |||
@@ -220,7 +220,7 @@ func (t *TemporaryUploadRepository) WriteTree() (string, error) { | |||
treeHash, stderr, err := process.GetManager().ExecDir(5*time.Minute, | |||
t.basePath, | |||
fmt.Sprintf("WriteTree (git write-tree): %s", t.basePath), | |||
"git", "write-tree") | |||
git.GitExecutable, "write-tree") | |||
if err != nil { | |||
return "", fmt.Errorf("git write-tree: %s", stderr) | |||
} | |||
@@ -240,7 +240,7 @@ func (t *TemporaryUploadRepository) GetLastCommitByRef(ref string) (string, erro | |||
treeHash, stderr, err := process.GetManager().ExecDir(5*time.Minute, | |||
t.basePath, | |||
fmt.Sprintf("GetLastCommit (git rev-parse %s): %s", ref, t.basePath), | |||
"git", "rev-parse", ref) | |||
git.GitExecutable, "rev-parse", ref) | |||
if err != nil { | |||
return "", fmt.Errorf("git rev-parse %s: %s", ref, stderr) | |||
} | |||
@@ -267,7 +267,7 @@ func (t *TemporaryUploadRepository) CommitTree(author, committer *models.User, t | |||
t.basePath, | |||
fmt.Sprintf("commitTree (git commit-tree): %s", t.basePath), | |||
env, | |||
"git", "commit-tree", treeHash, "-p", "HEAD", "-m", message) | |||
git.GitExecutable, "commit-tree", treeHash, "-p", "HEAD", "-m", message) | |||
if err != nil { | |||
return "", fmt.Errorf("git commit-tree: %s", stderr) | |||
} | |||
@@ -283,7 +283,7 @@ func (t *TemporaryUploadRepository) Push(doer *models.User, commitHash string, b | |||
t.basePath, | |||
fmt.Sprintf("actuallyPush (git push): %s", t.basePath), | |||
env, | |||
"git", "push", t.repo.RepoPath(), strings.TrimSpace(commitHash)+":refs/heads/"+strings.TrimSpace(branch)); err != nil { | |||
git.GitExecutable, "push", t.repo.RepoPath(), strings.TrimSpace(commitHash)+":refs/heads/"+strings.TrimSpace(branch)); err != nil { | |||
return fmt.Errorf("git push: %s", stderr) | |||
} | |||
return nil | |||
@@ -297,7 +297,7 @@ func (t *TemporaryUploadRepository) DiffIndex() (diff *models.Diff, err error) { | |||
stdErr := new(bytes.Buffer) | |||
cmd := exec.CommandContext(ctx, "git", "diff-index", "--cached", "-p", "HEAD") | |||
cmd := exec.CommandContext(ctx, git.GitExecutable, "diff-index", "--cached", "-p", "HEAD") | |||
cmd.Dir = t.basePath | |||
cmd.Stderr = stdErr | |||
@@ -341,7 +341,7 @@ func (t *TemporaryUploadRepository) CheckAttribute(attribute string, args ...str | |||
} | |||
} | |||
cmd := exec.CommandContext(ctx, "git", cmdArgs...) | |||
cmd := exec.CommandContext(ctx, git.GitExecutable, cmdArgs...) | |||
desc := fmt.Sprintf("checkAttr: (git check-attr) %s %v", attribute, cmdArgs) | |||
cmd.Dir = t.basePath | |||
cmd.Stdout = stdOut |
@@ -131,14 +131,14 @@ func RefBlame(ctx *context.Context) { | |||
ctx.Data["FileSize"] = blob.Size() | |||
ctx.Data["FileName"] = blob.Name() | |||
blameReader, err := models.CreateBlameReader(models.RepoPath(userName, repoName), commitID, fileName) | |||
blameReader, err := git.CreateBlameReader(models.RepoPath(userName, repoName), commitID, fileName) | |||
if err != nil { | |||
ctx.NotFound("CreateBlameReader", err) | |||
return | |||
} | |||
defer blameReader.Close() | |||
blameParts := make([]models.BlamePart, 0) | |||
blameParts := make([]git.BlamePart, 0) | |||
for { | |||
blamePart, err := blameReader.NextPart() | |||
@@ -189,7 +189,7 @@ func RefBlame(ctx *context.Context) { | |||
ctx.HTML(200, tplBlame) | |||
} | |||
func renderBlame(ctx *context.Context, blameParts []models.BlamePart, commitNames map[string]models.UserCommit) { | |||
func renderBlame(ctx *context.Context, blameParts []git.BlamePart, commitNames map[string]models.UserCommit) { | |||
repoLink := ctx.Repo.RepoLink | |||
var lines = make([]string, 0) |
@@ -22,6 +22,7 @@ import ( | |||
"code.gitea.io/gitea/modules/auth" | |||
"code.gitea.io/gitea/modules/base" | |||
"code.gitea.io/gitea/modules/context" | |||
"code.gitea.io/gitea/modules/git" | |||
"code.gitea.io/gitea/modules/log" | |||
"code.gitea.io/gitea/modules/setting" | |||
"code.gitea.io/gitea/modules/util" | |||
@@ -343,19 +344,11 @@ var routes = []route{ | |||
{regexp.MustCompile(`(.*?)/objects/pack/pack-[0-9a-f]{40}\.idx$`), "GET", getIdxFile}, | |||
} | |||
// FIXME: use process module | |||
func gitCommand(dir string, args ...string) []byte { | |||
cmd := exec.Command("git", args...) | |||
cmd.Dir = dir | |||
out, err := cmd.Output() | |||
func getGitConfig(option, dir string) string { | |||
out, err := git.NewCommand("config", option).RunInDir(dir) | |||
if err != nil { | |||
log.Error("%v - %s", err, out) | |||
} | |||
return out | |||
} | |||
func getGitConfig(option, dir string) string { | |||
out := string(gitCommand(dir, "config", option)) | |||
return out[0 : len(out)-1] | |||
} | |||
@@ -422,7 +415,7 @@ func serviceRPC(h serviceHandler, service string) { | |||
h.environ = append(h.environ, "SSH_ORIGINAL_COMMAND="+service) | |||
var stderr bytes.Buffer | |||
cmd := exec.Command("git", service, "--stateless-rpc", h.dir) | |||
cmd := exec.Command(git.GitExecutable, service, "--stateless-rpc", h.dir) | |||
cmd.Dir = h.dir | |||
if service == "receive-pack" { | |||
cmd.Env = append(os.Environ(), h.environ...) | |||
@@ -453,7 +446,11 @@ func getServiceType(r *http.Request) string { | |||
} | |||
func updateServerInfo(dir string) []byte { | |||
return gitCommand(dir, "update-server-info") | |||
out, err := git.NewCommand("update-server-info").RunInDirBytes(dir) | |||
if err != nil { | |||
log.Error(fmt.Sprintf("%v - %s", err, string(out))) | |||
} | |||
return out | |||
} | |||
func packetWrite(str string) []byte { | |||
@@ -468,7 +465,10 @@ func getInfoRefs(h serviceHandler) { | |||
h.setHeaderNoCache() | |||
if hasAccess(getServiceType(h.r), h, false) { | |||
service := getServiceType(h.r) | |||
refs := gitCommand(h.dir, service, "--stateless-rpc", "--advertise-refs", ".") | |||
refs, err := git.NewCommand(service, "--stateless-rpc", "--advertise-refs", ".").RunInDirBytes(h.dir) | |||
if err != nil { | |||
log.Error(fmt.Sprintf("%v - %s", err, string(refs))) | |||
} | |||
h.w.Header().Set("Content-Type", fmt.Sprintf("application/x-git-%s-advertisement", service)) | |||
h.w.WriteHeader(http.StatusOK) |