Fixes 4762 - Content API for Creating, Updating, Deleting Files (#6314)

modules/repofiles/update.go

@@ -0,0 +1,331 @@
+// 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 (
+	"fmt"
+	"path"
+	"strings"
+
+	"code.gitea.io/gitea/models"
+	"code.gitea.io/gitea/modules/git"
+	"code.gitea.io/gitea/modules/lfs"
+	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/sdk/gitea"
+)
+
+// IdentityOptions for a person's identity like an author or committer
+type IdentityOptions struct {
+	Name  string
+	Email string
+}
+
+// UpdateRepoFileOptions holds the repository file update options
+type UpdateRepoFileOptions struct {
+	LastCommitID string
+	OldBranch    string
+	NewBranch    string
+	TreePath     string
+	FromTreePath string
+	Message      string
+	Content      string
+	SHA          string
+	IsNewFile    bool
+	Author       *IdentityOptions
+	Committer    *IdentityOptions
+}
+
+// CreateOrUpdateRepoFile adds or updates a file in the given repository
+func CreateOrUpdateRepoFile(repo *models.Repository, doer *models.User, opts *UpdateRepoFileOptions) (*gitea.FileResponse, error) {
+	// If no branch name is set, assume master
+	if opts.OldBranch == "" {
+		opts.OldBranch = repo.DefaultBranch
+	}
+	if opts.NewBranch == "" {
+		opts.NewBranch = opts.OldBranch
+	}
+
+	// oldBranch must exist for this operation
+	if _, err := repo.GetBranch(opts.OldBranch); err != nil {
+		return nil, err
+	}
+
+	// A NewBranch can be specified for the file to be created/updated in a new branch.
+	// Check to make sure the branch does not already exist, otherwise we can't proceed.
+	// If we aren't branching to a new branch, make sure user can commit to the given branch
+	if opts.NewBranch != opts.OldBranch {
+		existingBranch, err := repo.GetBranch(opts.NewBranch)
+		if existingBranch != nil {
+			return nil, models.ErrBranchAlreadyExists{
+				BranchName: opts.NewBranch,
+			}
+		}
+		if err != nil && !models.IsErrBranchNotExist(err) {
+			return nil, err
+		}
+	} else {
+		if protected, _ := repo.IsProtectedBranchForPush(opts.OldBranch, doer); protected {
+			return nil, models.ErrUserCannotCommit{UserName: doer.LowerName}
+		}
+	}
+
+	// If FromTreePath is not set, set it to the opts.TreePath
+	if opts.TreePath != "" && opts.FromTreePath == "" {
+		opts.FromTreePath = opts.TreePath
+	}
+
+	// Check that the path given in opts.treePath is valid (not a git path)
+	treePath := CleanUploadFileName(opts.TreePath)
+	if treePath == "" {
+		return nil, models.ErrFilenameInvalid{
+			Path: opts.TreePath,
+		}
+	}
+	// If there is a fromTreePath (we are copying it), also clean it up
+	fromTreePath := CleanUploadFileName(opts.FromTreePath)
+	if fromTreePath == "" && opts.FromTreePath != "" {
+		return nil, models.ErrFilenameInvalid{
+			Path: opts.FromTreePath,
+		}
+	}
+
+	message := strings.TrimSpace(opts.Message)
+
+	author, committer := GetAuthorAndCommitterUsers(opts.Committer, opts.Author, doer)
+
+	t, err := NewTemporaryUploadRepository(repo)
+	defer t.Close()
+	if err != nil {
+		return nil, err
+	}
+	if err := t.Clone(opts.OldBranch); err != nil {
+		return nil, err
+	}
+	if err := t.SetDefaultIndex(); err != nil {
+		return nil, err
+	}
+
+	// Get the commit of the original branch
+	commit, err := t.GetBranchCommit(opts.OldBranch)
+	if err != nil {
+		return nil, err // Couldn't get a commit for the branch
+	}
+
+	// Assigned LastCommitID in opts if it hasn't been set
+	if opts.LastCommitID == "" {
+		opts.LastCommitID = commit.ID.String()
+	}
+
+	if !opts.IsNewFile {
+		fromEntry, err := commit.GetTreeEntryByPath(fromTreePath)
+		if err != nil {
+			return nil, err
+		}
+		if opts.SHA != "" {
+			// If a SHA was given and the SHA given doesn't match the SHA of the fromTreePath, throw error
+			if opts.SHA != fromEntry.ID.String() {
+				return nil, models.ErrSHADoesNotMatch{
+					Path:       treePath,
+					GivenSHA:   opts.SHA,
+					CurrentSHA: fromEntry.ID.String(),
+				}
+			}
+		} else if opts.LastCommitID != "" {
+			// If a lastCommitID was given and it doesn't match the commitID of the head of the branch throw
+			// an error, but only if we aren't creating a new branch.
+			if commit.ID.String() != opts.LastCommitID && opts.OldBranch == opts.NewBranch {
+				if changed, err := commit.FileChangedSinceCommit(treePath, opts.LastCommitID); err != nil {
+					return nil, err
+				} else if changed {
+					return nil, models.ErrCommitIDDoesNotMatch{
+						GivenCommitID:   opts.LastCommitID,
+						CurrentCommitID: opts.LastCommitID,
+					}
+				}
+				// The file wasn't modified, so we are good to delete it
+			}
+		} else {
+			// When updating a file, a lastCommitID or SHA needs to be given to make sure other commits
+			// haven't been made. We throw an error if one wasn't provided.
+			return nil, models.ErrSHAOrCommitIDNotProvided{}
+		}
+	}
+
+	// For the path where this file will be created/updated, we need to make
+	// sure no parts of the path are existing files or links except for the last
+	// item in the path which is the file name, and that shouldn't exist IF it is
+	// a new file OR is being moved to a new path.
+	treePathParts := strings.Split(treePath, "/")
+	subTreePath := ""
+	for index, part := range treePathParts {
+		subTreePath = path.Join(subTreePath, part)
+		entry, err := commit.GetTreeEntryByPath(subTreePath)
+		if err != nil {
+			if git.IsErrNotExist(err) {
+				// Means there is no item with that name, so we're good
+				break
+			}
+			return nil, err
+		}
+		if index < len(treePathParts)-1 {
+			if !entry.IsDir() {
+				return nil, models.ErrFilePathInvalid{
+					Message: fmt.Sprintf("a file exists where you’re trying to create a subdirectory [path: %s]", subTreePath),
+					Path:    subTreePath,
+					Name:    part,
+					Type:    git.EntryModeBlob,
+				}
+			}
+		} else if entry.IsLink() {
+			return nil, models.ErrFilePathInvalid{
+				Message: fmt.Sprintf("a symbolic link exists where you’re trying to create a subdirectory [path: %s]", subTreePath),
+				Path:    subTreePath,
+				Name:    part,
+				Type:    git.EntryModeSymlink,
+			}
+		} else if entry.IsDir() {
+			return nil, models.ErrFilePathInvalid{
+				Message: fmt.Sprintf("a directory exists where you’re trying to create a file [path: %s]", subTreePath),
+				Path:    subTreePath,
+				Name:    part,
+				Type:    git.EntryModeTree,
+			}
+		} else if fromTreePath != treePath || opts.IsNewFile {
+			// The entry shouldn't exist if we are creating new file or moving to a new path
+			return nil, models.ErrRepoFileAlreadyExists{
+				Path: treePath,
+			}
+		}
+
+	}
+
+	// Get the two paths (might be the same if not moving) from the index if they exist
+	filesInIndex, err := t.LsFiles(opts.TreePath, opts.FromTreePath)
+	if err != nil {
+		return nil, fmt.Errorf("UpdateRepoFile: %v", err)
+	}
+	// If is a new file (not updating) then the given path shouldn't exist
+	if opts.IsNewFile {
+		for _, file := range filesInIndex {
+			if file == opts.TreePath {
+				return nil, models.ErrRepoFileAlreadyExists{
+					Path: opts.TreePath,
+				}
+			}
+		}
+	}
+
+	// Remove the old path from the tree
+	if fromTreePath != treePath && len(filesInIndex) > 0 {
+		for _, file := range filesInIndex {
+			if file == fromTreePath {
+				if err := t.RemoveFilesFromIndex(opts.FromTreePath); err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+
+	// Check there is no way this can return multiple infos
+	filename2attribute2info, err := t.CheckAttribute("filter", treePath)
+	if err != nil {
+		return nil, err
+	}
+
+	content := opts.Content
+	var lfsMetaObject *models.LFSMetaObject
+
+	if filename2attribute2info[treePath] != nil && filename2attribute2info[treePath]["filter"] == "lfs" {
+		// OK so we are supposed to LFS this data!
+		oid, err := models.GenerateLFSOid(strings.NewReader(opts.Content))
+		if err != nil {
+			return nil, err
+		}
+		lfsMetaObject = &models.LFSMetaObject{Oid: oid, Size: int64(len(opts.Content)), RepositoryID: repo.ID}
+		content = lfsMetaObject.Pointer()
+	}
+
+	// Add the object to the database
+	objectHash, err := t.HashObject(strings.NewReader(content))
+	if err != nil {
+		return nil, err
+	}
+
+	// Add the object to the index
+	if err := t.AddObjectToIndex("100644", objectHash, treePath); err != nil {
+		return nil, err
+	}
+
+	// Now write the tree
+	treeHash, err := t.WriteTree()
+	if err != nil {
+		return nil, err
+	}
+
+	// Now commit the tree
+	commitHash, err := t.CommitTree(author, committer, treeHash, message)
+	if err != nil {
+		return nil, err
+	}
+
+	if lfsMetaObject != nil {
+		// We have an LFS object - create it
+		lfsMetaObject, err = models.NewLFSMetaObject(lfsMetaObject)
+		if err != nil {
+			return nil, err
+		}
+		contentStore := &lfs.ContentStore{BasePath: setting.LFS.ContentPath}
+		if !contentStore.Exists(lfsMetaObject) {
+			if err := contentStore.Put(lfsMetaObject, strings.NewReader(opts.Content)); err != nil {
+				if err2 := repo.RemoveLFSMetaObjectByOid(lfsMetaObject.Oid); err2 != nil {
+					return nil, fmt.Errorf("Error whilst removing failed inserted LFS object %s: %v (Prev Error: %v)", lfsMetaObject.Oid, err2, err)
+				}
+				return nil, err
+			}
+		}
+	}
+
+	// Then push this tree to NewBranch
+	if err := t.Push(doer, commitHash, opts.NewBranch); err != nil {
+		return nil, err
+	}
+
+	// Simulate push event.
+	oldCommitID := opts.LastCommitID
+	if opts.NewBranch != opts.OldBranch || oldCommitID == "" {
+		oldCommitID = git.EmptySHA
+	}
+
+	if err = repo.GetOwner(); err != nil {
+		return nil, fmt.Errorf("GetOwner: %v", err)
+	}
+	err = models.PushUpdate(
+		opts.NewBranch,
+		models.PushUpdateOptions{
+			PusherID:     doer.ID,
+			PusherName:   doer.Name,
+			RepoUserName: repo.Owner.Name,
+			RepoName:     repo.Name,
+			RefFullName:  git.BranchPrefix + opts.NewBranch,
+			OldCommitID:  oldCommitID,
+			NewCommitID:  commitHash,
+		},
+	)
+	if err != nil {
+		return nil, fmt.Errorf("PushUpdate: %v", err)
+	}
+	models.UpdateRepoIndexer(repo)
+
+	commit, err = t.GetCommit(commitHash)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := GetFileResponseFromCommit(repo, commit, opts.NewBranch, treePath)
+	if err != nil {
+		return nil, err
+	}
+	return file, nil
+}