Remove Uncyclo LocalCopy Checkouts

Author: zeripath

models/helper_directory.go

@@ -27,7 +27,7 @@ func LocalCopyPath() string {
 // CreateTemporaryPath creates a temporary path
 func CreateTemporaryPath(prefix string) (string, error) {
 	timeStr := com.ToStr(time.Now().Nanosecond()) // SHOULD USE SOMETHING UNIQUE
-	basePath := filepath.Join(LocalCopyPath(), prefix+"-"+timeStr+".git")
+	basePath := path.Join(LocalCopyPath(), prefix+"-"+timeStr+".git")
 	if err := os.MkdirAll(filepath.Dir(basePath), os.ModePerm); err != nil {
 		log.Error("Unable to create temporary directory: %s (%v)", basePath, err)
 		return "", fmt.Errorf("Failed to create dir %s: %v", basePath, err)

models/repo_branch.go

@@ -15,29 +15,6 @@ import (
 	"github.com/Unknwon/com"
 )
 
-// discardLocalRepoBranchChanges discards local commits/changes of
-// given branch to make sure it is even to remote branch.
-func discardLocalRepoBranchChanges(localPath, branch string) error {
-	if !com.IsExist(localPath) {
-		return nil
-	}
-	// No need to check if nothing in the repository.
-	if !git.IsBranchExist(localPath, branch) {
-		return nil
-	}
-
-	refName := "origin/" + branch
-	if err := git.ResetHEAD(localPath, true, refName); err != nil {
-		return fmt.Errorf("git reset --hard %s: %v", refName, err)
-	}
-	return nil
-}
-
-// DiscardLocalRepoBranchChanges discards the local repository branch changes
-func (repo *Repository) DiscardLocalRepoBranchChanges(branch string) error {
-	return discardLocalRepoBranchChanges(repo.LocalCopyPath(), branch)
-}
-
 // checkoutNewBranch checks out to a new branch from the a branch name.
 func checkoutNewBranch(repoPath, localPath, oldBranch, newBranch string) error {
 	if err := git.Checkout(localPath, git.CheckoutOptions{

models/wiki.go

@@ -6,14 +6,14 @@ package models
 
 import (
 	"fmt"
-	"io/ioutil"
 	"net/url"
 	"os"
 	"path"
 	"path/filepath"
 	"strings"
 
 	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/sync"
 
@@ -102,21 +102,6 @@ func (repo *Repository) LocalUncycloPath() string {
 	return path.Join(LocalUncycloPath(), com.ToStr(repo.ID))
 }
 
-// UpdateLocalUncyclo makes sure the local copy of repository wiki is up-to-date.
-func (repo *Repository) updateLocalUncyclo() error {
-	// Don't pass branch name here because it fails to clone and
-	// checkout to a specific branch when wiki is an empty repository.
-	var branch = ""
-	if com.IsExist(repo.LocalUncycloPath()) {
-		branch = "master"
-	}
-	return UpdateLocalCopyBranch(repo.UncycloPath(), repo.LocalUncycloPath(), branch)
-}
-
-func discardLocalUncycloChanges(localPath string) error {
-	return discardLocalRepoBranchChanges(localPath, "master")
-}
-
 // nameAllowed checks if a wiki name is allowed
 func nameAllowed(name string) error {
 	for _, reservedName := range reservedUncycloNames {
@@ -132,66 +117,120 @@ func (repo *Repository) updateUncycloPage(doer *User, oldUncycloName, newUncycloName, con
 	if err = nameAllowed(newUncycloName); err != nil {
 		return err
 	}
-
 	wikiWorkingPool.CheckIn(com.ToStr(repo.ID))
 	defer wikiWorkingPool.CheckOut(com.ToStr(repo.ID))
 
 	if err = repo.InitUncyclo(); err != nil {
 		return fmt.Errorf("InitUncyclo: %v", err)
 	}
 
-	localPath := repo.LocalUncycloPath()
-	if err = discardLocalUncycloChanges(localPath); err != nil {
-		return fmt.Errorf("discardLocalUncycloChanges: %v", err)
-	} else if err = repo.updateLocalUncyclo(); err != nil {
-		return fmt.Errorf("UpdateLocalUncyclo: %v", err)
-	}
+	hasMasterBranch := git.IsBranchExist(repo.UncycloPath(), "master")
 
-	newUncycloPath := path.Join(localPath, UncycloNameToFilename(newUncycloName))
+	return WithTemporaryPath("update-wiki", func(basePath string) error {
+		cloneOpts := git.CloneRepoOptions{
+			Bare:   true,
+			Shared: true,
+		}
 
-	// If not a new file, show perform update not create.
-	if isNew {
-		if com.IsExist(newUncycloPath) {
-			return ErrUncycloAlreadyExist{newUncycloPath}
+		if hasMasterBranch {
+			cloneOpts.Branch = "master"
 		}
-	} else {
-		oldUncycloPath := path.Join(localPath, UncycloNameToFilename(oldUncycloName))
-		if err := os.Remove(oldUncycloPath); err != nil {
-			return fmt.Errorf("Failed to remove %s: %v", oldUncycloPath, err)
+
+		if err := git.Clone(repo.UncycloPath(), basePath, cloneOpts); err != nil {
+			log.Error("Failed to clone repository: %s (%v)", repo.FullName(), err)
+			return fmt.Errorf("Failed to clone repository: %s (%v)", repo.FullName(), err)
 		}
-	}
 
-	// SECURITY: if new file is a symlink to non-exist critical file,
-	// attack content can be written to the target file (e.g. authorized_keys2)
-	// as a new page operation.
-	// So we want to make sure the symlink is removed before write anything.
-	// The new file we created will be in normal text format.
-	if err = os.RemoveAll(newUncycloPath); err != nil {
-		return err
-	}
+		gitRepo, err := git.OpenRepository(basePath)
+		if err != nil {
+			log.Error("Unable to open temporary repository: %s (%v)", basePath, err)
+			return fmt.Errorf("Failed to open new temporary repository in: %s %v", basePath, err)
+		}
 
-	if err = ioutil.WriteFile(newUncycloPath, []byte(content), 0666); err != nil {
-		return fmt.Errorf("WriteFile: %v", err)
-	}
+		if hasMasterBranch {
+			if err := gitRepo.ReadTreeToIndex("HEAD"); err != nil {
+				log.Error("Unable to read HEAD tree to index in: %s %v", basePath, err)
+				return fmt.Errorf("Unable to read HEAD tree to index in: %s %v", basePath, err)
+			}
+		}
 
-	if len(message) == 0 {
-		message = "Update page '" + newUncycloName + "'"
-	}
-	if err = git.AddChanges(localPath, true); err != nil {
-		return fmt.Errorf("AddChanges: %v", err)
-	} else if err = git.CommitChanges(localPath, git.CommitChangesOptions{
-		Committer: doer.NewGitSig(),
-		Message:   message,
-	}); err != nil {
-		return fmt.Errorf("CommitChanges: %v", err)
-	} else if err = git.Push(localPath, git.PushOptions{
-		Remote: "origin",
-		Branch: "master",
-	}); err != nil {
-		return fmt.Errorf("Push: %v", err)
-	}
+		newUncycloPath := UncycloNameToFilename(newUncycloName)
+		if isNew {
+			filesInIndex, err := gitRepo.LsFiles(newUncycloPath)
+			if err != nil {
+				log.Error("%v", err)
+				return err
+			}
+			for _, file := range filesInIndex {
+				if file == newUncycloPath {
+					return ErrUncycloAlreadyExist{newUncycloPath}
+				}
+			}
+		} else {
+			oldUncycloPath := UncycloNameToFilename(oldUncycloName)
+			filesInIndex, err := gitRepo.LsFiles(oldUncycloPath)
+			if err != nil {
+				log.Error("%v", err)
+				return err
+			}
+			found := false
+			for _, file := range filesInIndex {
+				if file == oldUncycloPath {
+					found = true
+					break
+				}
+			}
+			if found {
+				err := gitRepo.RemoveFilesFromIndex(oldUncycloPath)
+				if err != nil {
+					log.Error("%v", err)
+					return err
+				}
+			}
+		}
 
-	return nil
+		// FIXME: The wiki doesn't have lfs support at present - if this changes need to check attributes here
+
+		objectHash, err := gitRepo.HashObject(strings.NewReader(content))
+		if err != nil {
+			log.Error("%v", err)
+			return err
+		}
+
+		if err := gitRepo.AddObjectToIndex("100644", objectHash, newUncycloPath); err != nil {
+			log.Error("%v", err)
+			return err
+		}
+
+		tree, err := gitRepo.WriteTree()
+		if err != nil {
+			log.Error("%v", err)
+			return err
+		}
+
+		commitTreeOpts := git.CommitTreeOpts{
+			Message: message,
+		}
+		if hasMasterBranch {
+			commitTreeOpts.Parents = []string{"HEAD"}
+		}
+		commitHash, err := gitRepo.CommitTree(doer.NewGitSig(), tree, commitTreeOpts)
+		if err != nil {
+			log.Error("%v", err)
+			return err
+		}
+
+		if err := git.Push(basePath, git.PushOptions{
+			Remote: "origin",
+			Branch: fmt.Sprintf("%s:%s%s", commitHash.String(), git.BranchPrefix, "master"),
+			Env:    PushingEnvironment(doer, repo),
+		}); err != nil {
+			log.Error("%v", err)
+			return fmt.Errorf("Push: %v", err)
+		}
+
+		return nil
+	})
 }
 
 // AddUncycloPage adds a new wiki page with a given wikiPath.
@@ -210,34 +249,73 @@ func (repo *Repository) DeleteUncycloPage(doer *User, wikiName string) (err error)
 	wikiWorkingPool.CheckIn(com.ToStr(repo.ID))
 	defer wikiWorkingPool.CheckOut(com.ToStr(repo.ID))
 
-	localPath := repo.LocalUncycloPath()
-	if err = discardLocalUncycloChanges(localPath); err != nil {
-		return fmt.Errorf("discardLocalUncycloChanges: %v", err)
-	} else if err = repo.updateLocalUncyclo(); err != nil {
-		return fmt.Errorf("UpdateLocalUncyclo: %v", err)
+	if err = repo.InitUncyclo(); err != nil {
+		return fmt.Errorf("InitUncyclo: %v", err)
 	}
 
-	filename := path.Join(localPath, UncycloNameToFilename(wikiName))
+	return WithTemporaryPath("update-wiki", func(basePath string) error {
+		if err := git.Clone(repo.UncycloPath(), basePath, git.CloneRepoOptions{
+			Bare:   true,
+			Shared: true,
+			Branch: "master",
+		}); err != nil {
+			log.Error("Failed to clone repository: %s (%v)", repo.FullName(), err)
+			return fmt.Errorf("Failed to clone repository: %s (%v)", repo.FullName(), err)
+		}
 
-	if err := os.Remove(filename); err != nil {
-		return fmt.Errorf("Failed to remove %s: %v", filename, err)
-	}
+		gitRepo, err := git.OpenRepository(basePath)
+		if err != nil {
+			log.Error("Unable to open temporary repository: %s (%v)", basePath, err)
+			return fmt.Errorf("Failed to open new temporary repository in: %s %v", basePath, err)
+		}
 
-	message := "Delete page '" + wikiName + "'"
-
-	if err = git.AddChanges(localPath, true); err != nil {
-		return fmt.Errorf("AddChanges: %v", err)
-	} else if err = git.CommitChanges(localPath, git.CommitChangesOptions{
-		Committer: doer.NewGitSig(),
-		Message:   message,
-	}); err != nil {
-		return fmt.Errorf("CommitChanges: %v", err)
-	} else if err = git.Push(localPath, git.PushOptions{
-		Remote: "origin",
-		Branch: "master",
-	}); err != nil {
-		return fmt.Errorf("Push: %v", err)
-	}
+		if err := gitRepo.ReadTreeToIndex("HEAD"); err != nil {
+			log.Error("Unable to read HEAD tree to index in: %s %v", basePath, err)
+			return fmt.Errorf("Unable to read HEAD tree to index in: %s %v", basePath, err)
+		}
 
-	return nil
+		wikiPath := UncycloNameToFilename(wikiName)
+		filesInIndex, err := gitRepo.LsFiles(wikiPath)
+		found := false
+		for _, file := range filesInIndex {
+			if file == wikiPath {
+				found = true
+				break
+			}
+		}
+		if found {
+			err := gitRepo.RemoveFilesFromIndex(wikiPath)
+			if err != nil {
+				return err
+			}
+		} else {
+			return os.ErrNotExist
+		}
+
+		// FIXME: The wiki doesn't have lfs support at present - if this changes need to check attributes here
+
+		tree, err := gitRepo.WriteTree()
+		if err != nil {
+			return err
+		}
+		message := "Delete page '" + wikiName + "'"
+
+		commitHash, err := gitRepo.CommitTree(doer.NewGitSig(), tree, git.CommitTreeOpts{
+			Message: message,
+			Parents: []string{"HEAD"},
+		})
+		if err != nil {
+			return err
+		}
+
+		if err := git.Push(basePath, git.PushOptions{
+			Remote: "origin",
+			Branch: fmt.Sprintf("%s:%s%s", commitHash.String(), git.BranchPrefix, "master"),
+			Env:    PushingEnvironment(doer, repo),
+		}); err != nil {
+			return fmt.Errorf("Push: %v", err)
+		}
+
+		return nil
+	})
 }

modules/git/command.go

@@ -55,6 +55,12 @@ func (c *Command) AddArguments(args ...string) *Command {
 // RunInDirTimeoutEnvPipeline executes the command in given directory with given timeout,
 // it pipes stdout and stderr to given io.Writer.
 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
 	}
@@ -73,6 +79,7 @@ func (c *Command) RunInDirTimeoutEnvPipeline(env []string, timeout time.Duration
 	cmd.Dir = dir
 	cmd.Stdout = stdout
 	cmd.Stderr = stderr
+	cmd.Stdin = stdin
 	if err := cmd.Start(); err != nil {
 		return err
 	}
@@ -90,6 +97,12 @@ func (c *Command) RunInDirTimeoutPipeline(timeout time.Duration, dir string, std
 	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) {
@@ -114,7 +127,13 @@ func (c *Command) RunInDirTimeoutEnv(env []string, timeout time.Duration, dir st
 // 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