Remove local clones & make hooks run on merge/edit/upload (#6672)

* Add options to git.Clone to make it more capable

* Begin the process of removing the local copy and tidy up

* Remove Wiki LocalCopy Checkouts

* Remove the last LocalRepo helpers

* Remove WithTemporaryFile

* Enable push-hooks for these routes

* Ensure tests cope with hooks

Signed-off-by: Andrew Thornton <art27@cantab.net>

* Remove Repository.LocalCopyPath()

* Move temporary repo to use the standard temporary path

* Fix the tests

Signed-off-by: Andrew Thornton <art27@cantab.net>

* Remove LocalWikiPath

* Fix missing remove

Signed-off-by: Andrew Thornton <art27@cantab.net>

* Use AppURL for Oauth user link (#6894)

* Use AppURL for Oauth user link

Fix #6843

* Update oauth.go

* Update oauth.go

* internal/ssh: ignore env command totally (#6825)

* ssh: ignore env command totally

* Remove commented code 

Needed fix described in issue #6889

* Escape the commit message on issues update and title in telegram hook (#6901)

* update sdk to latest (#6903)

* improve description of branch protection (fix #6886) (#6906)

The branch protection description text were not quite accurate.

* Fix logging documentation (#6904)

* ENABLE_MACARON_REDIRECT should be REDIRECT_MACARON_LOG

* Allow DISABLE_ROUTER_LOG to be set in the [log] section

* [skip ci] Updated translations via Crowdin

* Move sdk structs to modules/structs (#6905)

* move sdk structs to moduels/structs

* fix tests

* fix fmt

* fix swagger

* fix vendor

10 files changed, 245 insertions, 590 deletions

diff --git a/modules/git/command.go b/modules/git/command.go
index 3602717702..d6221ce268 100644
--- a/modules/git/command.go
+++ b/modules/git/command.go
@@ -52,9 +52,15 @@ func (c *Command) AddArguments(args ...string) *Command {
 	return c
 }
 
-// RunInDirTimeoutPipeline executes the command in given directory with given timeout,
+// RunInDirTimeoutEnvPipeline executes the command in given directory with given timeout,
 // it pipes stdout and stderr to given io.Writer.
-func (c *Command) RunInDirTimeoutPipeline(timeout time.Duration, dir string, stdout, stderr io.Writer) error {
+func (c *Command) RunInDirTimeoutEnvPipeline(env []string, timeout time.Duration, dir string, stdout, stderr io.Writer) error {
+	return c.RunInDirTimeoutEnvFullPipeline(env, timeout, dir, stdout, stderr, nil)
+}
+
+// RunInDirTimeoutEnvFullPipeline executes the command in given directory with given timeout,
+// it pipes stdout and stderr to given io.Writer and passes in an io.Reader as stdin.
+func (c *Command) RunInDirTimeoutEnvFullPipeline(env []string, timeout time.Duration, dir string, stdout, stderr io.Writer, stdin io.Reader) error {
 	if timeout == -1 {
 		timeout = DefaultCommandExecutionTimeout
 	}
@@ -69,9 +75,11 @@ func (c *Command) RunInDirTimeoutPipeline(timeout time.Duration, dir string, std
 	defer cancel()
 
 	cmd := exec.CommandContext(ctx, c.name, c.args...)
+	cmd.Env = env
 	cmd.Dir = dir
 	cmd.Stdout = stdout
 	cmd.Stderr = stderr
+	cmd.Stdin = stdin
 	if err := cmd.Start(); err != nil {
 		return err
 	}
@@ -83,12 +91,30 @@ func (c *Command) RunInDirTimeoutPipeline(timeout time.Duration, dir string, std
 	return ctx.Err()
 }
 
+// RunInDirTimeoutPipeline executes the command in given directory with given timeout,
+// it pipes stdout and stderr to given io.Writer.
+func (c *Command) RunInDirTimeoutPipeline(timeout time.Duration, dir string, stdout, stderr io.Writer) error {
+	return c.RunInDirTimeoutEnvPipeline(nil, timeout, dir, stdout, stderr)
+}
+
+// RunInDirTimeoutFullPipeline executes the command in given directory with given timeout,
+// it pipes stdout and stderr to given io.Writer, and stdin from the given io.Reader
+func (c *Command) RunInDirTimeoutFullPipeline(timeout time.Duration, dir string, stdout, stderr io.Writer, stdin io.Reader) error {
+	return c.RunInDirTimeoutEnvFullPipeline(nil, timeout, dir, stdout, stderr, stdin)
+}
+
 // RunInDirTimeout executes the command in given directory with given timeout,
 // and returns stdout in []byte and error (combined with stderr).
 func (c *Command) RunInDirTimeout(timeout time.Duration, dir string) ([]byte, error) {
+	return c.RunInDirTimeoutEnv(nil, timeout, dir)
+}
+
+// RunInDirTimeoutEnv executes the command in given directory with given timeout,
+// and returns stdout in []byte and error (combined with stderr).
+func (c *Command) RunInDirTimeoutEnv(env []string, timeout time.Duration, dir string) ([]byte, error) {
 	stdout := new(bytes.Buffer)
 	stderr := new(bytes.Buffer)
-	if err := c.RunInDirTimeoutPipeline(timeout, dir, stdout, stderr); err != nil {
+	if err := c.RunInDirTimeoutEnvPipeline(env, timeout, dir, stdout, stderr); err != nil {
 		return nil, concatenateError(err, stderr.String())
 	}
 
@@ -101,7 +127,13 @@ func (c *Command) RunInDirTimeout(timeout time.Duration, dir string) ([]byte, er
 // RunInDirPipeline executes the command in given directory,
 // it pipes stdout and stderr to given io.Writer.
 func (c *Command) RunInDirPipeline(dir string, stdout, stderr io.Writer) error {
-	return c.RunInDirTimeoutPipeline(-1, dir, stdout, stderr)
+	return c.RunInDirFullPipeline(dir, stdout, stderr, nil)
+}
+
+// RunInDirFullPipeline executes the command in given directory,
+// it pipes stdout and stderr to given io.Writer.
+func (c *Command) RunInDirFullPipeline(dir string, stdout, stderr io.Writer, stdin io.Reader) error {
+	return c.RunInDirTimeoutFullPipeline(-1, dir, stdout, stderr, stdin)
 }
 
 // RunInDirBytes executes the command in given directory
@@ -113,7 +145,13 @@ func (c *Command) RunInDirBytes(dir string) ([]byte, error) {
 // RunInDir executes the command in given directory
 // and returns stdout in string and error (combined with stderr).
 func (c *Command) RunInDir(dir string) (string, error) {
-	stdout, err := c.RunInDirTimeout(-1, dir)
+	return c.RunInDirWithEnv(dir, nil)
+}
+
+// RunInDirWithEnv executes the command in given directory
+// and returns stdout in string and error (combined with stderr).
+func (c *Command) RunInDirWithEnv(dir string, env []string) (string, error) {
+	stdout, err := c.RunInDirTimeoutEnv(env, -1, dir)
 	if err != nil {
 		return "", err
 	}
diff --git a/modules/git/repo.go b/modules/git/repo.go
index 8355f8811f..4be3164130 100644
--- a/modules/git/repo.go
+++ b/modules/git/repo.go
@@ -109,11 +109,13 @@ func OpenRepository(repoPath string) (*Repository, error) {
 
 // CloneRepoOptions options when clone a repository
 type CloneRepoOptions struct {
-	Timeout time.Duration
-	Mirror  bool
-	Bare    bool
-	Quiet   bool
-	Branch  string
+	Timeout    time.Duration
+	Mirror     bool
+	Bare       bool
+	Quiet      bool
+	Branch     string
+	Shared     bool
+	NoCheckout bool
 }
 
 // Clone clones original repository to target path.
@@ -133,10 +135,17 @@ func Clone(from, to string, opts CloneRepoOptions) (err error) {
 	if opts.Quiet {
 		cmd.AddArguments("--quiet")
 	}
+	if opts.Shared {
+		cmd.AddArguments("-s")
+	}
+	if opts.NoCheckout {
+		cmd.AddArguments("--no-checkout")
+	}
+
 	if len(opts.Branch) > 0 {
 		cmd.AddArguments("-b", opts.Branch)
 	}
-	cmd.AddArguments(from, to)
+	cmd.AddArguments("--", from, to)
 
 	if opts.Timeout <= 0 {
 		opts.Timeout = -1
@@ -181,6 +190,7 @@ type PushOptions struct {
 	Remote string
 	Branch string
 	Force  bool
+	Env    []string
 }
 
 // Push pushs local commits to given remote branch.
@@ -190,7 +200,7 @@ func Push(repoPath string, opts PushOptions) error {
 		cmd.AddArguments("-f")
 	}
 	cmd.AddArguments(opts.Remote, opts.Branch)
-	_, err := cmd.RunInDir(repoPath)
+	_, err := cmd.RunInDirWithEnv(repoPath, opts.Env)
 	return err
 }
 
diff --git a/modules/git/repo_branch.go b/modules/git/repo_branch.go
index 83689ee9dc..116bdbee82 100644
--- a/modules/git/repo_branch.go
+++ b/modules/git/repo_branch.go
@@ -17,7 +17,7 @@ const BranchPrefix = "refs/heads/"
 
 // IsReferenceExist returns true if given reference exists in the repository.
 func IsReferenceExist(repoPath, name string) bool {
-	_, err := NewCommand("show-ref", "--verify", name).RunInDir(repoPath)
+	_, err := NewCommand("show-ref", "--verify", "--", name).RunInDir(repoPath)
 	return err == nil
 }
 
@@ -145,9 +145,9 @@ func (repo *Repository) DeleteBranch(name string, opts DeleteBranchOptions) erro
 }
 
 // CreateBranch create a new branch
-func (repo *Repository) CreateBranch(branch, newBranch string) error {
+func (repo *Repository) CreateBranch(branch, oldbranchOrCommit string) error {
 	cmd := NewCommand("branch")
-	cmd.AddArguments(branch, newBranch)
+	cmd.AddArguments("--", branch, oldbranchOrCommit)
 
 	_, err := cmd.RunInDir(repo.Path)
 
diff --git a/modules/git/repo_index.go b/modules/git/repo_index.go
new file mode 100644
index 0000000000..4d26563a91
--- /dev/null
+++ b/modules/git/repo_index.go
@@ -0,0 +1,98 @@
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package git
+
+import (
+	"bytes"
+	"strings"
+)
+
+// ReadTreeToIndex reads a treeish to the index
+func (repo *Repository) ReadTreeToIndex(treeish string) error {
+	if len(treeish) != 40 {
+		res, err := NewCommand("rev-parse", treeish).RunInDir(repo.Path)
+		if err != nil {
+			return err
+		}
+		if len(res) > 0 {
+			treeish = res[:len(res)-1]
+		}
+	}
+	id, err := NewIDFromString(treeish)
+	if err != nil {
+		return err
+	}
+	return repo.readTreeToIndex(id)
+}
+
+func (repo *Repository) readTreeToIndex(id SHA1) error {
+	_, err := NewCommand("read-tree", id.String()).RunInDir(repo.Path)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// EmptyIndex empties the index
+func (repo *Repository) EmptyIndex() error {
+	_, err := NewCommand("read-tree", "--empty").RunInDir(repo.Path)
+	return err
+}
+
+// LsFiles checks if the given filenames are in the index
+func (repo *Repository) LsFiles(filenames ...string) ([]string, error) {
+	cmd := NewCommand("ls-files", "-z", "--")
+	for _, arg := range filenames {
+		if arg != "" {
+			cmd.AddArguments(arg)
+		}
+	}
+	res, err := cmd.RunInDirBytes(repo.Path)
+	if err != nil {
+		return nil, err
+	}
+	filelist := make([]string, 0, len(filenames))
+	for _, line := range bytes.Split(res, []byte{'\000'}) {
+		filelist = append(filelist, string(line))
+	}
+
+	return filelist, err
+}
+
+// RemoveFilesFromIndex removes given filenames from the index - it does not check whether they are present.
+func (repo *Repository) RemoveFilesFromIndex(filenames ...string) error {
+	cmd := NewCommand("update-index", "--remove", "-z", "--index-info")
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	buffer := new(bytes.Buffer)
+	for _, file := range filenames {
+		if file != "" {
+			buffer.WriteString("0 0000000000000000000000000000000000000000\t")
+			buffer.WriteString(file)
+			buffer.WriteByte('\000')
+		}
+	}
+	return cmd.RunInDirFullPipeline(repo.Path, stdout, stderr, bytes.NewReader(buffer.Bytes()))
+}
+
+// AddObjectToIndex adds the provided object hash to the index at the provided filename
+func (repo *Repository) AddObjectToIndex(mode string, object SHA1, filename string) error {
+	cmd := NewCommand("update-index", "--add", "--replace", "--cacheinfo", mode, object.String(), filename)
+	_, err := cmd.RunInDir(repo.Path)
+	return err
+}
+
+// WriteTree writes the current index as a tree to the object db and returns its hash
+func (repo *Repository) WriteTree() (*Tree, error) {
+	res, err := NewCommand("write-tree").RunInDir(repo.Path)
+	if err != nil {
+		return nil, err
+	}
+	id, err := NewIDFromString(strings.TrimSpace(res))
+	if err != nil {
+		return nil, err
+	}
+	return NewTree(repo, id), nil
+}
diff --git a/modules/git/repo_object.go b/modules/git/repo_object.go
index 3be8400d22..67060e30b0 100644
--- a/modules/git/repo_object.go
+++ b/modules/git/repo_object.go
@@ -4,6 +4,12 @@
 
 package git
 
+import (
+	"bytes"
+	"io"
+	"strings"
+)
+
 // ObjectType git object type
 type ObjectType string
 
@@ -17,3 +23,24 @@ const (
 	// ObjectTag tag object type
 	ObjectTag ObjectType = "tag"
 )
+
+// HashObject takes a reader and returns SHA1 hash for that reader
+func (repo *Repository) HashObject(reader io.Reader) (SHA1, error) {
+	idStr, err := repo.hashObject(reader)
+	if err != nil {
+		return SHA1{}, err
+	}
+	return NewIDFromString(idStr)
+}
+
+func (repo *Repository) hashObject(reader io.Reader) (string, error) {
+	cmd := NewCommand("hash-object", "-w", "--stdin")
+	stdout := new(bytes.Buffer)
+	stderr := new(bytes.Buffer)
+	err := cmd.RunInDirFullPipeline(repo.Path, stdout, stderr, reader)
+
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(stdout.String()), nil
+}
diff --git a/modules/git/repo_tree.go b/modules/git/repo_tree.go
index 8bb7291744..7d32d3685c 100644
--- a/modules/git/repo_tree.go
+++ b/modules/git/repo_tree.go
@@ -6,6 +6,11 @@
 package git
 
 import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
 	"gopkg.in/src-d/go-git.v4/plumbing"
 )
 
@@ -47,3 +52,48 @@ func (repo *Repository) GetTree(idStr string) (*Tree, error) {
 	treeObject.ResolvedID = resolvedID
 	return treeObject, nil
 }
+
+// CommitTreeOpts represents the possible options to CommitTree
+type CommitTreeOpts struct {
+	Parents   []string
+	Message   string
+	KeyID     string
+	NoGPGSign bool
+}
+
+// CommitTree creates a commit from a given tree id for the user with provided message
+func (repo *Repository) CommitTree(sig *Signature, tree *Tree, opts CommitTreeOpts) (SHA1, error) {
+	commitTimeStr := time.Now().Format(time.UnixDate)
+
+	// Because this may call hooks we should pass in the environment
+	env := append(os.Environ(),
+		"GIT_AUTHOR_NAME="+sig.Name,
+		"GIT_AUTHOR_EMAIL="+sig.Email,
+		"GIT_AUTHOR_DATE="+commitTimeStr,
+		"GIT_COMMITTER_NAME="+sig.Name,
+		"GIT_COMMITTER_EMAIL="+sig.Email,
+		"GIT_COMMITTER_DATE="+commitTimeStr,
+	)
+	cmd := NewCommand("commit-tree", tree.ID.String())
+
+	for _, parent := range opts.Parents {
+		cmd.AddArguments("-p", parent)
+	}
+
+	cmd.AddArguments("-m", opts.Message)
+
+	if opts.KeyID != "" {
+		cmd.AddArguments(fmt.Sprintf("-S%s", opts.KeyID))
+	}
+
+	if opts.NoGPGSign {
+		cmd.AddArguments("--no-gpg-sign")
+	}
+
+	res, err := cmd.RunInDirWithEnv(repo.Path, env)
+
+	if err != nil {
+		return SHA1{}, err
+	}
+	return NewIDFromString(strings.TrimSpace(res))
+}
diff --git a/modules/repofiles/delete_test.go b/modules/repofiles/delete_test.go
deleted file mode 100644
index 9d034066f5..0000000000
--- a/modules/repofiles/delete_test.go
+++ /dev/null
@@ -1,183 +0,0 @@
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package repofiles
-
-import (
-	"testing"
-
-	"code.gitea.io/gitea/models"
-	api "code.gitea.io/gitea/modules/structs"
-	"code.gitea.io/gitea/modules/test"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func getDeleteRepoFileOptions(repo *models.Repository) *DeleteRepoFileOptions {
-	return &DeleteRepoFileOptions{
-		LastCommitID: "",
-		OldBranch:    repo.DefaultBranch,
-		NewBranch:    repo.DefaultBranch,
-		TreePath:     "README.md",
-		Message:      "Deletes README.md",
-		SHA:          "4b4851ad51df6a7d9f25c979345979eaeb5b349f",
-		Author:       nil,
-		Committer:    nil,
-	}
-}
-
-func getExpectedDeleteFileResponse() *api.FileResponse {
-	return &api.FileResponse{
-		Content: nil,
-		Commit: &api.FileCommitResponse{
-			CommitMeta: api.CommitMeta{
-				URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/commits/65f1bf27bc3bf70f64657658635e66094edbcb4d",
-				SHA: "65f1bf27bc3bf70f64657658635e66094edbcb4d",
-			},
-			HTMLURL: "https://try.gitea.io/user2/repo1/commit/65f1bf27bc3bf70f64657658635e66094edbcb4d",
-			Author: &api.CommitUser{
-				Identity: api.Identity{
-					Name:  "user1",
-					Email: "address1@example.com",
-				},
-				Date: "2017-03-19T20:47:59Z",
-			},
-			Committer: &api.CommitUser{
-				Identity: api.Identity{
-					Name:  "Ethan Koenig",
-					Email: "ethantkoenig@gmail.com",
-				},
-				Date: "2017-03-19T20:47:59Z",
-			},
-			Parents: []*api.CommitMeta{},
-			Message: "Initial commit\n",
-			Tree: &api.CommitMeta{
-				URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/trees/2a2f1d4670728a2e10049e345bd7a276468beab6",
-				SHA: "2a2f1d4670728a2e10049e345bd7a276468beab6",
-			},
-		},
-		Verification: &api.PayloadCommitVerification{
-			Verified:  false,
-			Reason:    "",
-			Signature: "",
-			Payload:   "",
-		},
-	}
-}
-
-func TestDeleteRepoFile(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-	opts := getDeleteRepoFileOptions(repo)
-
-	t.Run("Delete README.md file", func(t *testing.T) {
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Nil(t, err)
-		expectedFileResponse := getExpectedDeleteFileResponse()
-		assert.EqualValues(t, expectedFileResponse, fileResponse)
-	})
-
-	t.Run("Verify README.md has been deleted", func(t *testing.T) {
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		expectedError := "repository file does not exist [path: " + opts.TreePath + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-}
-
-// Test opts with branch names removed, same results
-func TestDeleteRepoFileWithoutBranchNames(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-	opts := getDeleteRepoFileOptions(repo)
-	opts.OldBranch = ""
-	opts.NewBranch = ""
-
-	t.Run("Delete README.md without Branch Name", func(t *testing.T) {
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Nil(t, err)
-		expectedFileResponse := getExpectedDeleteFileResponse()
-		assert.EqualValues(t, expectedFileResponse, fileResponse)
-	})
-}
-
-func TestDeleteRepoFileErrors(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-
-	t.Run("Bad branch", func(t *testing.T) {
-		opts := getDeleteRepoFileOptions(repo)
-		opts.OldBranch = "bad_branch"
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Error(t, err)
-		assert.Nil(t, fileResponse)
-		expectedError := "branch does not exist [name: " + opts.OldBranch + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("Bad SHA", func(t *testing.T) {
-		opts := getDeleteRepoFileOptions(repo)
-		origSHA := opts.SHA
-		opts.SHA = "bad_sha"
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "sha does not match [given: " + opts.SHA + ", expected: " + origSHA + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("New branch already exists", func(t *testing.T) {
-		opts := getDeleteRepoFileOptions(repo)
-		opts.NewBranch = "develop"
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "branch already exists [name: " + opts.NewBranch + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("TreePath is empty:", func(t *testing.T) {
-		opts := getDeleteRepoFileOptions(repo)
-		opts.TreePath = ""
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "path contains a malformed path component [path: ]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("TreePath is a git directory:", func(t *testing.T) {
-		opts := getDeleteRepoFileOptions(repo)
-		opts.TreePath = ".git"
-		fileResponse, err := DeleteRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "path contains a malformed path component [path: " + opts.TreePath + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-}
diff --git a/modules/repofiles/temp_repo.go b/modules/repofiles/temp_repo.go
index 46e03f5650..ec35628676 100644
--- a/modules/repofiles/temp_repo.go
+++ b/modules/repofiles/temp_repo.go
@@ -11,17 +11,15 @@ import (
 	"io"
 	"os"
 	"os/exec"
-	"path"
 	"regexp"
 	"strings"
 	"time"
 
 	"code.gitea.io/gitea/models"
 	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/process"
 	"code.gitea.io/gitea/modules/setting"
-
-	"github.com/Unknwon/com"
 )
 
 // TemporaryUploadRepository is a type to wrap our upload repositories as a shallow clone
@@ -33,13 +31,9 @@ type TemporaryUploadRepository struct {
 
 // NewTemporaryUploadRepository creates a new temporary upload repository
 func NewTemporaryUploadRepository(repo *models.Repository) (*TemporaryUploadRepository, error) {
-	timeStr := com.ToStr(time.Now().Nanosecond()) // SHOULD USE SOMETHING UNIQUE
-	basePath := path.Join(models.LocalCopyPath(), "upload-"+timeStr+".git")
-	if err := os.MkdirAll(path.Dir(basePath), os.ModePerm); err != nil {
-		return nil, fmt.Errorf("failed to create dir %s: %v", basePath, err)
-	}
-	if repo.RepoPath() == "" {
-		return nil, fmt.Errorf("no path to repository on system")
+	basePath, err := models.CreateTemporaryPath("upload")
+	if err != nil {
+		return nil, err
 	}
 	t := &TemporaryUploadRepository{repo: repo, basePath: basePath}
 	return t, nil
@@ -47,8 +41,8 @@ func NewTemporaryUploadRepository(repo *models.Repository) (*TemporaryUploadRepo
 
 // Close the repository cleaning up all files
 func (t *TemporaryUploadRepository) Close() {
-	if _, err := os.Stat(t.basePath); !os.IsNotExist(err) {
-		os.RemoveAll(t.basePath)
+	if err := models.RemoveTemporaryPath(t.basePath); err != nil {
+		log.Error("Failed to remove temporary path %s: %v", t.basePath, err)
 	}
 }
 
@@ -282,27 +276,8 @@ func (t *TemporaryUploadRepository) CommitTree(author, committer *models.User, t
 
 // Push the provided commitHash to the repository branch by the provided user
 func (t *TemporaryUploadRepository) Push(doer *models.User, commitHash string, branch string) error {
-	isWiki := "false"
-	if strings.HasSuffix(t.repo.Name, ".wiki") {
-		isWiki = "true"
-	}
-
-	sig := doer.NewGitSig()
-
-	// FIXME: Should we add SSH_ORIGINAL_COMMAND to this
 	// Because calls hooks we need to pass in the environment
-	env := append(os.Environ(),
-		"GIT_AUTHOR_NAME="+sig.Name,
-		"GIT_AUTHOR_EMAIL="+sig.Email,
-		"GIT_COMMITTER_NAME="+sig.Name,
-		"GIT_COMMITTER_EMAIL="+sig.Email,
-		models.EnvRepoName+"="+t.repo.Name,
-		models.EnvRepoUsername+"="+t.repo.OwnerName,
-		models.EnvRepoIsWiki+"="+isWiki,
-		models.EnvPusherName+"="+doer.Name,
-		models.EnvPusherID+"="+fmt.Sprintf("%d", doer.ID),
-		models.ProtectedBranchRepoID+"="+fmt.Sprintf("%d", t.repo.ID),
-	)
+	env := models.PushingEnvironment(doer, t.repo)
 
 	if _, stderr, err := process.GetManager().ExecDirEnv(5*time.Minute,
 		t.basePath,
diff --git a/modules/repofiles/update_test.go b/modules/repofiles/update_test.go
deleted file mode 100644
index a3a0b0a420..0000000000
--- a/modules/repofiles/update_test.go
+++ /dev/null
@@ -1,357 +0,0 @@
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package repofiles
-
-import (
-	"testing"
-	"time"
-
-	"code.gitea.io/gitea/models"
-	"code.gitea.io/gitea/modules/git"
-	api "code.gitea.io/gitea/modules/structs"
-	"code.gitea.io/gitea/modules/test"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func getCreateRepoFileOptions(repo *models.Repository) *UpdateRepoFileOptions {
-	return &UpdateRepoFileOptions{
-		OldBranch: repo.DefaultBranch,
-		NewBranch: repo.DefaultBranch,
-		TreePath:  "new/file.txt",
-		Message:   "Creates new/file.txt",
-		Content:   "This is a NEW file",
-		IsNewFile: true,
-		Author:    nil,
-		Committer: nil,
-	}
-}
-
-func getUpdateRepoFileOptions(repo *models.Repository) *UpdateRepoFileOptions {
-	return &UpdateRepoFileOptions{
-		OldBranch: repo.DefaultBranch,
-		NewBranch: repo.DefaultBranch,
-		TreePath:  "README.md",
-		Message:   "Updates README.md",
-		SHA:       "4b4851ad51df6a7d9f25c979345979eaeb5b349f",
-		Content:   "This is UPDATED content for the README file",
-		IsNewFile: false,
-		Author:    nil,
-		Committer: nil,
-	}
-}
-
-func getExpectedFileResponseForCreate(commitID string) *api.FileResponse {
-	return &api.FileResponse{
-		Content: &api.FileContentResponse{
-			Name:        "file.txt",
-			Path:        "new/file.txt",
-			SHA:         "103ff9234cefeee5ec5361d22b49fbb04d385885",
-			Size:        18,
-			URL:         "https://try.gitea.io/api/v1/repos/user2/repo1/contents/new/file.txt",
-			HTMLURL:     "https://try.gitea.io/user2/repo1/blob/master/new/file.txt",
-			GitURL:      "https://try.gitea.io/api/v1/repos/user2/repo1/git/blobs/103ff9234cefeee5ec5361d22b49fbb04d385885",
-			DownloadURL: "https://try.gitea.io/user2/repo1/raw/branch/master/new/file.txt",
-			Type:        "blob",
-			Links: &api.FileLinksResponse{
-				Self:    "https://try.gitea.io/api/v1/repos/user2/repo1/contents/new/file.txt",
-				GitURL:  "https://try.gitea.io/api/v1/repos/user2/repo1/git/blobs/103ff9234cefeee5ec5361d22b49fbb04d385885",
-				HTMLURL: "https://try.gitea.io/user2/repo1/blob/master/new/file.txt",
-			},
-		},
-		Commit: &api.FileCommitResponse{
-			CommitMeta: api.CommitMeta{
-				URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/commits/" + commitID,
-				SHA: commitID,
-			},
-			HTMLURL: "https://try.gitea.io/user2/repo1/commit/" + commitID,
-			Author: &api.CommitUser{
-				Identity: api.Identity{
-					Name:  "User Two",
-					Email: "user2@",
-				},
-				Date: time.Now().UTC().Format(time.RFC3339),
-			},
-			Committer: &api.CommitUser{
-				Identity: api.Identity{
-					Name:  "User Two",
-					Email: "user2@",
-				},
-				Date: time.Now().UTC().Format(time.RFC3339),
-			},
-			Parents: []*api.CommitMeta{
-				{
-					URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/commits/65f1bf27bc3bf70f64657658635e66094edbcb4d",
-					SHA: "65f1bf27bc3bf70f64657658635e66094edbcb4d",
-				},
-			},
-			Message: "Updates README.md\n",
-			Tree: &api.CommitMeta{
-				URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/trees/f93e3a1a1525fb5b91020da86e44810c87a2d7bc",
-				SHA: "f93e3a1a1525fb5b91020git dda86e44810c87a2d7bc",
-			},
-		},
-		Verification: &api.PayloadCommitVerification{
-			Verified:  false,
-			Reason:    "unsigned",
-			Signature: "",
-			Payload:   "",
-		},
-	}
-}
-
-func getExpectedFileResponseForUpdate(commitID string) *api.FileResponse {
-	return &api.FileResponse{
-		Content: &api.FileContentResponse{
-			Name:        "README.md",
-			Path:        "README.md",
-			SHA:         "dbf8d00e022e05b7e5cf7e535de857de57925647",
-			Size:        43,
-			URL:         "https://try.gitea.io/api/v1/repos/user2/repo1/contents/README.md",
-			HTMLURL:     "https://try.gitea.io/user2/repo1/blob/master/README.md",
-			GitURL:      "https://try.gitea.io/api/v1/repos/user2/repo1/git/blobs/dbf8d00e022e05b7e5cf7e535de857de57925647",
-			DownloadURL: "https://try.gitea.io/user2/repo1/raw/branch/master/README.md",
-			Type:        "blob",
-			Links: &api.FileLinksResponse{
-				Self:    "https://try.gitea.io/api/v1/repos/user2/repo1/contents/README.md",
-				GitURL:  "https://try.gitea.io/api/v1/repos/user2/repo1/git/blobs/dbf8d00e022e05b7e5cf7e535de857de57925647",
-				HTMLURL: "https://try.gitea.io/user2/repo1/blob/master/README.md",
-			},
-		},
-		Commit: &api.FileCommitResponse{
-			CommitMeta: api.CommitMeta{
-				URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/commits/" + commitID,
-				SHA: commitID,
-			},
-			HTMLURL: "https://try.gitea.io/user2/repo1/commit/" + commitID,
-			Author: &api.CommitUser{
-				Identity: api.Identity{
-					Name:  "User Two",
-					Email: "user2@",
-				},
-				Date: time.Now().UTC().Format(time.RFC3339),
-			},
-			Committer: &api.CommitUser{
-				Identity: api.Identity{
-					Name:  "User Two",
-					Email: "user2@",
-				},
-				Date: time.Now().UTC().Format(time.RFC3339),
-			},
-			Parents: []*api.CommitMeta{
-				{
-					URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/commits/65f1bf27bc3bf70f64657658635e66094edbcb4d",
-					SHA: "65f1bf27bc3bf70f64657658635e66094edbcb4d",
-				},
-			},
-			Message: "Updates README.md\n",
-			Tree: &api.CommitMeta{
-				URL: "https://try.gitea.io/api/v1/repos/user2/repo1/git/trees/f93e3a1a1525fb5b91020da86e44810c87a2d7bc",
-				SHA: "f93e3a1a1525fb5b91020da86e44810c87a2d7bc",
-			},
-		},
-		Verification: &api.PayloadCommitVerification{
-			Verified:  false,
-			Reason:    "unsigned",
-			Signature: "",
-			Payload:   "",
-		},
-	}
-}
-
-func TestCreateOrUpdateRepoFileForCreate(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-	opts := getCreateRepoFileOptions(repo)
-
-	// test
-	fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-
-	// asserts
-	assert.Nil(t, err)
-	gitRepo, _ := git.OpenRepository(repo.RepoPath())
-	commitID, _ := gitRepo.GetBranchCommitID(opts.NewBranch)
-	expectedFileResponse := getExpectedFileResponseForCreate(commitID)
-	assert.EqualValues(t, expectedFileResponse.Content, fileResponse.Content)
-	assert.EqualValues(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
-	assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
-	assert.EqualValues(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
-	assert.EqualValues(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
-}
-
-func TestCreateOrUpdateRepoFileForUpdate(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-	opts := getUpdateRepoFileOptions(repo)
-
-	// test
-	fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-
-	// asserts
-	assert.Nil(t, err)
-	gitRepo, _ := git.OpenRepository(repo.RepoPath())
-	commitID, _ := gitRepo.GetBranchCommitID(opts.NewBranch)
-	expectedFileResponse := getExpectedFileResponseForUpdate(commitID)
-	assert.EqualValues(t, expectedFileResponse.Content, fileResponse.Content)
-	assert.EqualValues(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
-	assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
-	assert.EqualValues(t, expectedFileResponse.Commit.Author.Email, fileResponse.Commit.Author.Email)
-	assert.EqualValues(t, expectedFileResponse.Commit.Author.Name, fileResponse.Commit.Author.Name)
-}
-
-func TestCreateOrUpdateRepoFileForUpdateWithFileMove(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-	opts := getUpdateRepoFileOptions(repo)
-	suffix := "_new"
-	opts.FromTreePath = "README.md"
-	opts.TreePath = "README.md" + suffix // new file name, README.md_new
-
-	// test
-	fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-
-	// asserts
-	assert.Nil(t, err)
-	gitRepo, _ := git.OpenRepository(repo.RepoPath())
-	commit, _ := gitRepo.GetBranchCommit(opts.NewBranch)
-	expectedFileResponse := getExpectedFileResponseForUpdate(commit.ID.String())
-	// assert that the old file no longer exists in the last commit of the branch
-	fromEntry, err := commit.GetTreeEntryByPath(opts.FromTreePath)
-	toEntry, err := commit.GetTreeEntryByPath(opts.TreePath)
-	assert.Nil(t, fromEntry)  // Should no longer exist here
-	assert.NotNil(t, toEntry) // Should exist here
-	// assert SHA has remained the same but paths use the new file name
-	assert.EqualValues(t, expectedFileResponse.Content.SHA, fileResponse.Content.SHA)
-	assert.EqualValues(t, expectedFileResponse.Content.Name+suffix, fileResponse.Content.Name)
-	assert.EqualValues(t, expectedFileResponse.Content.Path+suffix, fileResponse.Content.Path)
-	assert.EqualValues(t, expectedFileResponse.Content.URL+suffix, fileResponse.Content.URL)
-	assert.EqualValues(t, expectedFileResponse.Commit.SHA, fileResponse.Commit.SHA)
-	assert.EqualValues(t, expectedFileResponse.Commit.HTMLURL, fileResponse.Commit.HTMLURL)
-}
-
-// Test opts with branch names removed, should get same results as above test
-func TestCreateOrUpdateRepoFileWithoutBranchNames(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-	opts := getUpdateRepoFileOptions(repo)
-	opts.OldBranch = ""
-	opts.NewBranch = ""
-
-	// test
-	fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-
-	// asserts
-	assert.Nil(t, err)
-	gitRepo, _ := git.OpenRepository(repo.RepoPath())
-	commitID, _ := gitRepo.GetBranchCommitID(repo.DefaultBranch)
-	expectedFileResponse := getExpectedFileResponseForUpdate(commitID)
-	assert.EqualValues(t, expectedFileResponse.Content, fileResponse.Content)
-}
-
-func TestCreateOrUpdateRepoFileErrors(t *testing.T) {
-	// setup
-	models.PrepareTestEnv(t)
-	ctx := test.MockContext(t, "user2/repo1")
-	ctx.SetParams(":id", "1")
-	test.LoadRepo(t, ctx, 1)
-	test.LoadRepoCommit(t, ctx)
-	test.LoadUser(t, ctx, 2)
-	test.LoadGitRepo(t, ctx)
-	repo := ctx.Repo.Repository
-	doer := ctx.User
-
-	t.Run("bad branch", func(t *testing.T) {
-		opts := getUpdateRepoFileOptions(repo)
-		opts.OldBranch = "bad_branch"
-		fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-		assert.Error(t, err)
-		assert.Nil(t, fileResponse)
-		expectedError := "branch does not exist [name: " + opts.OldBranch + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("bad SHA", func(t *testing.T) {
-		opts := getUpdateRepoFileOptions(repo)
-		origSHA := opts.SHA
-		opts.SHA = "bad_sha"
-		fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "sha does not match [given: " + opts.SHA + ", expected: " + origSHA + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("new branch already exists", func(t *testing.T) {
-		opts := getUpdateRepoFileOptions(repo)
-		opts.NewBranch = "develop"
-		fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "branch already exists [name: " + opts.NewBranch + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("treePath is empty:", func(t *testing.T) {
-		opts := getUpdateRepoFileOptions(repo)
-		opts.TreePath = ""
-		fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "path contains a malformed path component [path: ]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("treePath is a git directory:", func(t *testing.T) {
-		opts := getUpdateRepoFileOptions(repo)
-		opts.TreePath = ".git"
-		fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "path contains a malformed path component [path: " + opts.TreePath + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-
-	t.Run("create file that already exists", func(t *testing.T) {
-		opts := getCreateRepoFileOptions(repo)
-		opts.TreePath = "README.md" //already exists
-		fileResponse, err := CreateOrUpdateRepoFile(repo, doer, opts)
-		assert.Nil(t, fileResponse)
-		assert.Error(t, err)
-		expectedError := "repository file already exists [path: " + opts.TreePath + "]"
-		assert.EqualError(t, err, expectedError)
-	})
-}
diff --git a/modules/setting/repository.go b/modules/setting/repository.go
index f47661efdf..98e3d6e826 100644
--- a/modules/setting/repository.go
+++ b/modules/setting/repository.go
@@ -53,7 +53,6 @@ var (
 		// Repository local settings
 		Local struct {
 			LocalCopyPath string
-			LocalWikiPath string
 		} `ini:"-"`
 
 		// Pull request settings
@@ -105,10 +104,8 @@ var (
 		// Repository local settings
 		Local: struct {
 			LocalCopyPath string
-			LocalWikiPath string
 		}{
 			LocalCopyPath: "tmp/local-repo",
-			LocalWikiPath: "tmp/local-wiki",
 		},
 
 		// Pull request settings