func()

in internal/gitaly/service/conflicts/resolve_conflicts.go [197:362]
125 lines of code
26 McCabe index (conditional complexity)

func (s *server) resolveConflictsWithGit(
	ctx context.Context,
	ours, theirs string,
	repo *localrepo.Repo,
	resolutions []conflict.Resolution,
	author git.Signature,
	commitMessage []byte,
) (git.ObjectID, error) {
	treeOID, err := repo.MergeTree(ctx, ours, theirs, localrepo.WithAllowUnrelatedHistories())

	var mergeConflictErr *localrepo.MergeTreeConflictError
	if errors.As(err, &mergeConflictErr) {
		conflictedFiles := mergeConflictErr.ConflictedFiles()
		checkedConflictedFiles := make(map[string]bool)
		for _, conflictedFile := range conflictedFiles {
			checkedConflictedFiles[conflictedFile] = false
		}

		tree, err := repo.ReadTree(ctx, treeOID.Revision(), localrepo.WithRecursive())
		if err != nil {
			return "", structerr.NewInternal("getting tree: %w", err)
		}

		objectReader, cancel, err := s.catfileCache.ObjectReader(ctx, repo)
		if err != nil {
			return "", structerr.NewInternal("getting objectreader: %w", err)
		}
		defer cancel()

		for _, resolution := range resolutions {
			path := resolution.NewPath

			if _, ok := checkedConflictedFiles[path]; !ok {
				// Note: this emulates the Ruby error that occurs when
				// there are no conflicts for a resolution
				return "", errors.New("NoMethodError: undefined method `resolve_lines' for nil:NilClass")
			}

			// We mark the file as checked, any remaining files, which don't have a resolution
			// associated, will throw an error.
			checkedConflictedFiles[path] = true

			conflictedBlob, err := tree.Get(path)
			if err != nil {
				return "", structerr.NewInternal("path not found in merged-tree: %w", err)
			}

			if conflictedBlob.Type != localrepo.Blob {
				return "", structerr.NewInternal("entry should be of type blob").
					WithMetadataItems(
						structerr.MetadataItem{Key: "path", Value: path},
						structerr.MetadataItem{Key: "type", Value: conflictedBlob.Type},
					)
			}

			// We first read the object completely to see if the content is similar
			// to the content in the resolution.
			if resolution.Content != "" {
				object, err := objectReader.Object(ctx, conflictedBlob.OID.Revision())
				if err != nil {
					return "", structerr.NewInternal("retrieving object: %w", err)
				}

				content, err := io.ReadAll(object)
				if err != nil {
					return "", structerr.NewInternal("reading object: %w", err)
				}

				// Git2Go conflict markers have filenames and git-merge-tree(1) has commit OIDs.
				// Rails uses the older form, so to check if the content is the same, we need to
				// adhere to this.
				//
				// Should be fixed with: https://gitlab.com/gitlab-org/git/-/issues/168
				content = bytes.ReplaceAll(content, []byte(ours), []byte(resolution.OldPath))
				content = bytes.ReplaceAll(content, []byte(theirs), []byte(resolution.NewPath))

				if bytes.Equal([]byte(resolution.Content), content) {
					// This is to keep the error consistent with git2go implementation
					return "", structerr.NewInvalidArgument("Resolved content has no changes for file %s", path)
				}
			}

			object, err := objectReader.Object(ctx, git.Revision(fmt.Sprintf("%s:%s", ours, resolution.OldPath)))
			if err != nil {
				return "", structerr.NewInternal("retrieving object: %w", err)
			}

			// Rails expects files ending with newlines to retain them post conflict, but
			// git swallows ending newlines. So we manually append them if necessary.
			needsNewLine := false

			oursContent, err := io.ReadAll(object)
			if err != nil {
				return "", structerr.NewInternal("reading object: %w", err)
			}
			if len(oursContent) > 0 {
				needsNewLine = oursContent[len(oursContent)-1] == '\n'
			}

			object, err = objectReader.Object(ctx, conflictedBlob.OID.Revision())
			if err != nil {
				return "", structerr.NewInternal("retrieving object: %w", err)
			}

			resolvedContent, err := conflict.Resolve(object, git.ObjectID(ours), git.ObjectID(theirs), path, resolution, needsNewLine)
			if err != nil {
				// If there are delimeters still present in the conflict resolution
				// this means the client hasn't addressed all conflicts.
				if errors.Is(err, conflict.ErrUnexpectedDelimiter) {
					return "", structerr.NewInvalidArgument("%w", err)
				}

				return "", structerr.NewInternal("%w", err)
			}

			blobOID, err := repo.WriteBlob(ctx, resolvedContent, localrepo.WriteBlobConfig{
				Path: filepath.Base(path),
			})
			if err != nil {
				return "", structerr.NewInternal("writing blob: %w", err)
			}

			err = tree.Add(path, localrepo.TreeEntry{
				OID:  blobOID,
				Mode: conflictedBlob.Mode,
				Path: filepath.Base(path),
				Type: localrepo.Blob,
			}, localrepo.WithOverwriteFile())
			if err != nil {
				return "", structerr.NewInternal("add to tree: %w", err)
			}
		}

		for conflictedFile, checked := range checkedConflictedFiles {
			if !checked {
				return "", fmt.Errorf("Missing resolutions for the following files: %s", conflictedFile) // this is to stay consistent with rugged-rails error
			}
		}

		err = tree.Write(ctx, repo)
		if err != nil {
			return "", structerr.NewInternal("write tree: %w", err)
		}

		treeOID = tree.OID
	} else if err != nil {
		return "", structerr.NewInternal("merge-tree: %w", err)
	}

	commitOID, err := repo.WriteCommit(ctx, localrepo.WriteCommitConfig{
		Parents:        []git.ObjectID{git.ObjectID(ours), git.ObjectID(theirs)},
		CommitterDate:  author.When,
		CommitterEmail: author.Email,
		CommitterName:  author.Name,
		AuthorDate:     author.When,
		AuthorEmail:    author.Email,
		AuthorName:     author.Name,
		Message:        string(commitMessage),
		TreeID:         treeOID,
	})
	if err != nil {
		return "", structerr.NewInternal("writing commit: %w", err)
	}

	return commitOID, nil
}