}

if !forcePush.Value() {

AddDynamicArguments(oldCommitID, "^"+opts.NewCommitIDs[i]).

if err != nil {

return nil, fmt.Errorf("failed to detect force push: %w", err)

} else if len(output) > 0 {

if setting.Repository.Signing.SigningKey == "default" || setting.Repository.Signing.SigningKey == "" {

// Can ignore the error here as it means that commit.gpgsign is not set

sign, valid := git.ParseBool(strings.TrimSpace(value))

if !sign || !valid {

return "", nil

}

return strings.TrimSpace(signingKey), &git.Signature{

Name: strings.TrimSpace(signingName),

Email: strings.TrimSpace(signingEmail),

numReposUpdated := 0

err := iterateRepositories(ctx, func(repo *repo_model.Repository) error {

numRepos++

// what we expect: default branch is valid, and HEAD points to it

if headErr == nil && defaultBranchErr == nil && head == repo.DefaultBranch {

}

// otherwise, let's try fixing HEAD

if err != nil {

logger.Warn("Failed to fix HEAD for %s/%s: %v", repo.OwnerName, repo.Name, err)

return nil

if !pr.HasMerged {

var err error

if err != nil {

var err2 error

if err2 != nil {

logger.Warn("Unable to get merge base for PR ID %d, #%d onto %s in %s/%s. Error: %v & %v", pr.ID, pr.Index, pr.BaseBranch, pr.BaseRepo.OwnerName, pr.BaseRepo.Name, err, err2)

return nil

}

}

} else {

if err != nil {

logger.Warn("Unable to get parents for merged PR ID %d, #%d onto %s in %s/%s. Error: %v", pr.ID, pr.Index, pr.BaseBranch, pr.BaseRepo.OwnerName, pr.BaseRepo.Name, err)

return nil

refs := append([]string{}, parents[1:]...)

refs = append(refs, pr.GetGitRefName())

if err != nil {

logger.Warn("Unable to get merge base for merged PR ID %d, #%d onto %s in %s/%s. Error: %v", pr.ID, pr.Index, pr.BaseBranch, pr.BaseRepo.OwnerName, pr.BaseRepo.Name, err)

return nil

defer r.Close()

if autofix {

return err

}

if err != nil {

return err

}

return nil, err

}

if useMergeBase {

cmd.AddArguments("--merge-base")

}

cmd.AddDynamicArguments(baseCommitID, headCommitID)

if runErr != nil {

log.Warn("git diff-tree: %v", runErr)

return nil, runErr

cmdCtx, cmdCancel := context.WithCancel(ctx)

defer cmdCancel()

objectFormat, err := gitRepo.GetObjectFormat()

if err != nil {

return nil, err

go func() {

stderr := &bytes.Buffer{}

Timeout: time.Duration(setting.Git.Timeout.Default) * time.Second,

Dir: repoPath,

Stdout: writer,

if pr.Head.CloneURL == "" || pr.Head.Ref == "" {

// Set head information if pr.Head.SHA is available

if pr.Head.SHA != "" {

if err != nil {

log.Error("PR #%d in %s/%s unable to update-ref for pr HEAD: %v", pr.Number, g.repoOwner, g.repoName, err)

}

if !ok {

// Set head information if pr.Head.SHA is available

if pr.Head.SHA != "" {

if err != nil {

log.Error("PR #%d in %s/%s unable to update-ref for pr HEAD: %v", pr.Number, g.repoOwner, g.repoName, err)

}

fetchArg = git.BranchPrefix + fetchArg

}

if err != nil {

log.Error("Fetch branch from %s failed: %v", pr.Head.CloneURL, err)

// We need to continue here so that the Head.Ref is reset and we attempt to set the gitref for the PR

pr.Head.SHA = headSha

}

if pr.Head.SHA != "" {

if err != nil {

log.Error("unable to set %s as the local head for PR #%d from %s in %s/%s. Error: %v", pr.Head.SHA, pr.Number, pr.Head.Ref, g.repoOwner, g.repoName, err)

}

fetchArg = git.BranchPrefix + fetchArg

}

if err != nil {

log.Error("Fetch branch from %s failed: %v", pr.Head.CloneURL, err)

return head, nil

pr.Head.SHA = headSha

}

if err != nil {

return "", err

}

// The SHA is empty

log.Warn("Empty reference, no pull head for PR #%d in %s/%s", pr.Number, g.repoOwner, g.repoName)

} else {

if err != nil {

// Git update-ref remove bad references with a relative path

log.Warn("Deprecated local head %s for PR #%d in %s/%s, removing %s", pr.Head.SHA, pr.Number, g.repoOwner, g.repoName, pr.GetGitRefName())

} else {

// set head information

if err != nil {

log.Error("unable to set %s as the local head for PR #%d from %s in %s/%s. Error: %v", pr.Head.SHA, pr.Number, pr.Head.Ref, g.repoOwner, g.repoName, err)

}

fromRepo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 1})

baseRef := "master"

assert.NoError(t, git.InitRepository(git.DefaultContext, fromRepo.RepoPath(), false, fromRepo.ObjectFormatName))

assert.NoError(t, err)

assert.NoError(t, os.WriteFile(filepath.Join(fromRepo.RepoPath(), "README.md"), []byte(fmt.Sprintf("# Testing Repository\n\nOriginally created in: %s", fromRepo.RepoPath())), 0o644))

assert.NoError(t, git.AddChanges(fromRepo.RepoPath(), true))

// fromRepo branch1

//

headRef := "branch1"

assert.NoError(t, err)

assert.NoError(t, os.WriteFile(filepath.Join(fromRepo.RepoPath(), "README.md"), []byte("SOMETHING"), 0o644))

assert.NoError(t, git.AddChanges(fromRepo.RepoPath(), true))

assert.NoError(t, git.CloneWithArgs(git.DefaultContext, nil, fromRepo.RepoPath(), forkRepo.RepoPath(), git.CloneRepoOptions{

Branch: headRef,

}))

assert.NoError(t, err)

assert.NoError(t, os.WriteFile(filepath.Join(forkRepo.RepoPath(), "README.md"), []byte(fmt.Sprintf("# branch2 %s", forkRepo.RepoPath())), 0o644))

assert.NoError(t, git.AddChanges(forkRepo.RepoPath(), true))

remoteName := m.GetRemoteName()

repoPath := m.GetRepository(ctx).RepoPath()

// Remove old remote

if err != nil && !git.IsRemoteNotExistError(err) {

return err

}

if err != nil && !git.IsRemoteNotExistError(err) {

return err

}

wikiPath := m.Repo.WikiPath()

wikiRemotePath := repo_module.WikiRemoteURL(ctx, addr)

// Remove old remote of wiki

if err != nil && !git.IsRemoteNotExistError(err) {

return err

}

if err != nil && !git.IsRemoteNotExistError(err) {

return err

}

stderrBuilder.Reset()

stdoutBuilder.Reset()

Timeout: timeout,

Dir: repoPath,

Stdout: stdoutBuilder,

log.Trace("SyncMirrors [repo: %-v]: running git remote update...", m.Repo)

// use fetch but not remote update because git fetch support --tags but remote update doesn't

if m.EnablePrune {

cmd.AddArguments("--prune")

}

stdoutBuilder := strings.Builder{}

stderrBuilder := strings.Builder{}

Timeout: timeout,

Dir: repoPath,

Env: envs,

// Successful prune - reattempt mirror

stderrBuilder.Reset()

stdoutBuilder.Reset()

Timeout: timeout,

Dir: repoPath,

Stdout: &stdoutBuilder,

log.Trace("SyncMirrors [repo: %-v Wiki]: running git remote update...", m.Repo)

stderrBuilder.Reset()

stdoutBuilder.Reset()

Timeout: timeout,

Dir: wikiPath,

Stdout: &stdoutBuilder,

stderrBuilder.Reset()

stdoutBuilder.Reset()

Timeout: timeout,

Dir: wikiPath,

Stdout: &stdoutBuilder,

// AddPushMirrorRemote registers the push mirror remote.

func AddPushMirrorRemote(ctx context.Context, m *repo_model.PushMirror, addr string) error {

addRemoteAndConfig := func(addr, path string) error {

return err

}

return err

}

return err

}

return nil

// RemovePushMirrorRemote removes the push mirror remote.

func RemovePushMirrorRemote(ctx context.Context, m *repo_model.PushMirror) error {

_ = m.GetRepository(ctx)

return err

}

if m.Repo.HasWiki() {

// The wiki remote may not exist

log.Warn("Wiki Remote[%d] could not be removed: %v", m.ID, err)

}

prHeadRef := pr.GetGitRefName()

// Check if the pull request is merged into BaseBranch

AddDynamicArguments(prHeadRef, pr.BaseBranch).

if strings.Contains(err.Error(), "exit status 1") {

// prHeadRef is not an ancestor of the base branch

return nil, nil

objectFormat := git.ObjectFormatFromName(pr.BaseRepo.ObjectFormatName)

// Get the commit from BaseBranch where the pull request got merged

if err != nil {

return nil, fmt.Errorf("git rev-list --ancestry-path --merges --reverse: %w", err)

} else if len(mergeCommit) < objectFormat.FullLength() {

)

mergeCtx.env = append(mergeCtx.env, repo_module.EnvPushTrigger+"="+string(pushTrigger))

// Push back to upstream.

// This cause an api call to "/api/internal/hook/post-receive/...",

// If it's merge, all db transaction and operations should be there but not here to prevent deadlock.

if strings.Contains(mergeCtx.errbuf.String(), "non-fast-forward") {

return "", &git.ErrPushOutOfDate{

StdOut: mergeCtx.outbuf.String(),

}

func commitAndSignNoAuthor(ctx *mergeContext, message string) error {

if ctx.signKeyID == "" {

cmdCommit.AddArguments("--no-gpg-sign")

} else {

cmdCommit.AddOptionFormat("-S%s", ctx.signKeyID)

}

log.Error("git commit %-v: %v\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), ctx.errbuf.String())

return fmt.Errorf("git commit %v: %w\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), ctx.errbuf.String())

}

}

func runMergeCommand(ctx *mergeContext, mergeStyle repo_model.MergeStyle, cmd *git.Command) error {

// Merge will leave a MERGE_HEAD file in the .git folder if there is a conflict

if _, statErr := os.Stat(filepath.Join(ctx.tmpBasePath, ".git", "MERGE_HEAD")); statErr == nil {

// We have a merge conflict error

// doMergeStyleFastForwardOnly merges the tracking into the current HEAD - which is assumed to be staging branch (equal to the pr.BaseBranch)

func doMergeStyleFastForwardOnly(ctx *mergeContext) error {

if err := runMergeCommand(ctx, repo_model.MergeStyleFastForwardOnly, cmd); err != nil {

log.Error("%-v Unable to merge tracking into base: %v", ctx.pr, err)

return err

// doMergeStyleMerge merges the tracking branch into the current HEAD - which is assumed to be the staging branch (equal to the pr.BaseBranch)

func doMergeStyleMerge(ctx *mergeContext, message string) error {

if err := runMergeCommand(ctx, repo_model.MergeStyleMerge, cmd); err != nil {

log.Error("%-v Unable to merge tracking into base: %v", ctx.pr, err)

return err

}

if expectedHeadCommitID != "" {

if err != nil {

defer cancel()

log.Error("failed to get sha of head branch in %-v: show-ref[%s] --hash refs/heads/tracking: %v", mergeCtx.pr, mergeCtx.tmpBasePath, err)

}

setConfig := func(key, value string) error {

log.Error("git config [%s -> %q]: %v\n%s\n%s", key, value, err, ctx.outbuf.String(), ctx.errbuf.String())

return fmt.Errorf("git config [%s -> %q]: %w\n%s\n%s", key, value, err, ctx.outbuf.String(), ctx.errbuf.String())

}

}

// Read base branch index

log.Error("git read-tree HEAD: %v\n%s\n%s", err, ctx.outbuf.String(), ctx.errbuf.String())

return fmt.Errorf("Unable to read base branch in to the index: %w\n%s\n%s", err, ctx.outbuf.String(), ctx.errbuf.String())

}

return 0, nil, nil

}

Dir: repoPath,

Stdout: diffOutWriter,

PipelineFunc: func(ctx context.Context, cancel context.CancelFunc) error {

// if there is a conflict it will return an ErrRebaseConflicts

func rebaseTrackingOnToBase(ctx *mergeContext, mergeStyle repo_model.MergeStyle) error {

// Checkout head branch

return fmt.Errorf("unable to git checkout tracking as staging in temp repo for %v: %w\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), ctx.errbuf.String())

}

ctx.outbuf.Reset()

ctx.errbuf.Reset()

// Rebase before merging

// Rebase will leave a REBASE_HEAD file in .git if there is a conflict

if _, statErr := os.Stat(filepath.Join(ctx.tmpBasePath, ".git", "REBASE_HEAD")); statErr == nil {

var commitSha string

// getRebaseAmendMessage composes the message to amend commits in rebase merge of a pull request.

func getRebaseAmendMessage(ctx *mergeContext, baseGitRepo *git.Repository) (message string, err error) {

// Get existing commit message.

if err != nil {

return "", err

}

return fmt.Errorf("Failed to get full commit id for HEAD: %w", err)

}

if err := runMergeCommand(ctx, repo_model.MergeStyleRebase, cmd); err != nil {

log.Error("Unable to merge staging into base: %v", err)

return err

}

if newMessage != "" {

log.Error("Unable to amend commit message: %v", err)

return err

}

// Perform rebase merge with merge commit.

func doMergeRebaseMergeCommit(ctx *mergeContext, message string) error {

if err := runMergeCommand(ctx, repo_model.MergeStyleRebaseMerge, cmd); err != nil {

log.Error("Unable to merge staging into base: %v", err)

}

// Checkout base branch again

log.Error("git checkout base prior to merge post staging rebase %-v: %v\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), ctx.errbuf.String())

return fmt.Errorf("git checkout base prior to merge post staging rebase %v: %w\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), ctx.errbuf.String())

}

return fmt.Errorf("getAuthorSignatureSquash: %w", err)

}

if err := runMergeCommand(ctx, repo_model.MergeStyleSquash, cmdMerge); err != nil {

log.Error("%-v Unable to merge --squash tracking into base: %v", ctx.pr, err)

return err

}

message += fmt.Sprintf("\nCo-committed-by: %s\n", sig.String())

}

AddOptionFormat("--author='%s <%s>'", sig.Name, sig.Email).

AddOptionFormat("--message=%s", message)

if ctx.signKeyID == "" {

} else {

cmdCommit.AddOptionFormat("-S%s", ctx.signKeyID)

}

log.Error("git commit %-v: %v\n%s\n%s", ctx.pr, err, ctx.outbuf.String(), ctx.errbuf.String())

return fmt.Errorf("git commit [%s:%s -> %s:%s]: %w\n%s\n%s", ctx.pr.HeadRepo.FullName(), ctx.pr.HeadBranch, ctx.pr.BaseRepo.FullName(), ctx.pr.BaseBranch, err, ctx.outbuf.String(), ctx.errbuf.String())

}

defer gitRepo.Close()

// 1. update merge base

if err != nil {

var err2 error

pr.MergeBase, err2 = gitRepo.GetRefCommitID(git.BranchPrefix + "base")

}

// Need to get the objects from the object db to attempt to merge

if err != nil {

return fmt.Errorf("unable to get root object: %s at path: %s for merging. Error: %w", file.stage1.sha, file.stage1.path, err)

}

_ = util.Remove(filepath.Join(tmpBasePath, root))

}()

if err != nil {

return fmt.Errorf("unable to get base object: %s at path: %s for merging. Error: %w", file.stage2.sha, file.stage2.path, err)

}

defer func() {

_ = util.Remove(base)

}()

if err != nil {

return fmt.Errorf("unable to get head object:%s at path: %s for merging. Error: %w", file.stage3.sha, file.stage3.path, err)

}

}()

// now git merge-file annoyingly takes a different order to the merge-tree ...

if conflictErr != nil {

return &errMergeConflict{file.stage2.path}

}

// base now contains the merged data

if err != nil {

return err

}

defer cancel()

// First we use read-tree to do a simple three-way merge

log.Error("Unable to run read-tree -m! Error: %v", err)

return false, nil, fmt.Errorf("unable to run read-tree -m! Error: %w", err)

}

// No conflicts detected so we need to check if the patch is empty...

// a. Write the newly merged tree and check the new tree-hash

var treeHash string

if err != nil {

return false, fmt.Errorf("unable to write unconflicted tree: %w\n`git ls-files -u`:\n%s", err, lsfiles)

}

treeHash = strings.TrimSpace(treeHash)

log.Trace("PullRequest[%d].testPatch (patchPath): %s", pr.ID, patchPath)

// 4. Read the base branch in to the index of the temporary repository

if err != nil {

return false, fmt.Errorf("git read-tree %s: %w", pr.BaseBranch, err)

}

prConfig := prUnit.PullRequestsConfig()

// 6. Prepare the arguments to apply the patch against the index

if prConfig.IgnoreWhitespaceConflicts {

cmdApply.AddArguments("--ignore-whitespace")

}

// 8. Run the check command

conflict = false

Dir: tmpBasePath,

Stderr: stderrWriter,

PipelineFunc: func(ctx context.Context, cancel context.CancelFunc) error {

}()

stderr := &strings.Builder{}

Dir: tmpBasePath,

Stdout: lsFilesWriter,

Stderr: stderr,

return false, fmt.Errorf("GetMergeBase: %w", err)

}

stdoutReader, stdoutWriter, err := os.Pipe()

if err != nil {

return false, fmt.Errorf("unable to open pipe for to run diff: %w", err)

}

stderr := new(bytes.Buffer)

Dir: prCtx.tmpBasePath,

Stdout: stdoutWriter,

Stderr: stderr,

return err

}

if err != nil {

log.Error("Unable to update ref in base repository for PR[%d] Error: %v", pr.ID, err)

}

return nil, nil, fmt.Errorf("Unable to add base repository to temporary repo [%s -> tmpBasePath]: %w", pr.BaseRepo.FullName(), err)

}

log.Error("%-v Unable to add base repository as origin [%s -> %s]: %v\n%s\n%s", pr, pr.BaseRepo.FullName(), tmpBasePath, err, prCtx.outbuf.String(), prCtx.errbuf.String())

cancel()

return nil, nil, fmt.Errorf("Unable to add base repository as origin [%s -> tmpBasePath]: %w\n%s\n%s", pr.BaseRepo.FullName(), err, prCtx.outbuf.String(), prCtx.errbuf.String())

}

log.Error("%-v Unable to fetch origin base branch [%s:%s -> base, original_base in %s]: %v:\n%s\n%s", pr, pr.BaseRepo.FullName(), pr.BaseBranch, tmpBasePath, err, prCtx.outbuf.String(), prCtx.errbuf.String())

cancel()

return nil, nil, fmt.Errorf("Unable to fetch origin base branch [%s:%s -> base, original_base in tmpBasePath]: %w\n%s\n%s", pr.BaseRepo.FullName(), pr.BaseBranch, err, prCtx.outbuf.String(), prCtx.errbuf.String())

}

log.Error("%-v Unable to set HEAD as base branch in [%s]: %v\n%s\n%s", pr, tmpBasePath, err, prCtx.outbuf.String(), prCtx.errbuf.String())

cancel()

return nil, nil, fmt.Errorf("Unable to set HEAD as base branch in tmpBasePath: %w\n%s\n%s", err, prCtx.outbuf.String(), prCtx.errbuf.String())

return nil, nil, fmt.Errorf("Unable to add head base repository to temporary repo [%s -> tmpBasePath]: %w", pr.HeadRepo.FullName(), err)

}

log.Error("%-v Unable to add head repository as head_repo [%s -> %s]: %v\n%s\n%s", pr, pr.HeadRepo.FullName(), tmpBasePath, err, prCtx.outbuf.String(), prCtx.errbuf.String())

cancel()

return nil, nil, fmt.Errorf("Unable to add head repository as head_repo [%s -> tmpBasePath]: %w\n%s\n%s", pr.HeadRepo.FullName(), err, prCtx.outbuf.String(), prCtx.errbuf.String())

} else {

headBranch = pr.GetGitRefName()

}

cancel()

if !git.IsBranchExist(ctx, pr.HeadRepo.RepoPath(), pr.HeadBranch) {

return nil, nil, git_model.ErrBranchNotExist{

defer cancel()

// Determine the old merge-base before the rebase - we use this for LFS push later on

oldMergeBase = strings.TrimSpace(oldMergeBase)

// Rebase the tracking branch on to the base as the staging branch

headUser = pr.HeadRepo.Owner

}

AddDynamicArguments(stagingBranch + ":" + git.BranchPrefix + pr.HeadBranch)

// Push back to the head repository.

mergeCtx.outbuf.Reset()

mergeCtx.errbuf.Reset()

Env: repo_module.FullPushingEnvironment(

headUser,

doer,

}

}

log.Error("DeleteReleaseByID (git tag -d): %d in %v Failed:\nStdout: %s\nError: %v", rel.ID, repo, stdout, err)

return fmt.Errorf("git tag -d: %w", err)

}

return fmt.Errorf("checkDaemonExportOK: %w", err)

}

log.Error("CreateRepository(git update-server-info) in %v: Stdout: %s\nError: %v", repo, stdout, err)

return fmt.Errorf("CreateRepository(git update-server-info): %w", err)

}

// GitGcRepo calls 'git gc' to remove unnecessary files and optimize the local repository

func GitGcRepo(ctx context.Context, repo *repo_model.Repository, timeout time.Duration, args git.TrustedCmdArgs) error {

log.Trace("Running git gc on %-v", repo)

var stdout string

var err error

if err != nil {

log.Error("Repository garbage collection failed for %-v. Stdout: %s\nError: %v", repo, stdout, err)

desc := fmt.Sprintf("Repository garbage collection failed for %s. Stdout: %s\nError: %v", repo.RepoPath(), stdout, err)

_ = stdoutWriter.Close()

}()

// AddOptionFormat("--max-count=%d", limit)

gitCmd.AddDynamicArguments(baseCommit.ID.String())

var extendedCommitStats []*ExtendedCommitStats

stderr := new(strings.Builder)

Dir: repo.Path,

Stdout: stdoutWriter,

Stderr: stderr,

)

// Clone to temporary path and do the init commit.

log.Error("Failed to clone from %v into %s: stdout: %s\nError: %v", repo, tmpDir, stdout, err)

return fmt.Errorf("git clone: %w", err)

}

return fmt.Errorf("checkDaemonExportOK: %w", err)

}

log.Error("CreateRepository(git update-server-info) in %v: Stdout: %s\nError: %v", repo, stdout, err)

rollbackRepo = repo

rollbackRepo.OwnerID = u.ID

if len(opts.License) > 0 {

licenses = append(licenses, ConvertLicenseName(opts.License))

if err != nil {

log.Error("CreateRepository(git rev-parse HEAD) in %v: Stdout: %s\nError: %v", repo, stdout, err)

rollbackRepo = repo

stdout := &strings.Builder{}

stderr := &strings.Builder{}

if git.DefaultFeatures().CheckVersionAtLeast("2.32") {

cmdApply.AddArguments("-3")

}

Dir: t.basePath,

Stdout: stdout,

Stderr: stderr,

// Clone the base repository to our path and set branch as the HEAD

func (t *TemporaryUploadRepository) Clone(branch string, bare bool) error {

if bare {

cmd.AddArguments("--bare")

}

stderr := err.Error()

if matched, _ := regexp.MatchString(".*Remote branch .* not found in upstream origin.*", stderr); matched {

return git.ErrBranchNotExist{

// SetDefaultIndex sets the git index to our HEAD

func (t *TemporaryUploadRepository) SetDefaultIndex() error {

return fmt.Errorf("SetDefaultIndex: %w", err)

}

return nil

// RefreshIndex looks at the current index and checks to see if merges or updates are needed by checking stat() information.

func (t *TemporaryUploadRepository) RefreshIndex() error {

return fmt.Errorf("RefreshIndex: %w", err)

}

return nil

stdOut := new(bytes.Buffer)

stdErr := new(bytes.Buffer)

Dir: t.basePath,

Stdout: stdOut,

Stderr: stdErr,

}

}

Dir: t.basePath,

Stdin: stdIn,

Stdout: stdOut,

stdOut := new(bytes.Buffer)

stdErr := new(bytes.Buffer)

Dir: t.basePath,

Stdin: content,

Stdout: stdOut,

// AddObjectToIndex adds the provided object hash to the index with the provided mode and path

func (t *TemporaryUploadRepository) AddObjectToIndex(mode, objectHash, objectPath string) error {

stderr := err.Error()

if matched, _ := regexp.MatchString(".*Invalid path '.*", stderr); matched {

return ErrFilePathInvalid{

// WriteTree writes the current index as a tree to the object db and returns its hash

func (t *TemporaryUploadRepository) WriteTree() (string, error) {

if err != nil {

log.Error("Unable to write tree in temporary repo: %s(%s): Error: %v", t.repo.FullName(), t.basePath, err)

return "", fmt.Errorf("Unable to write-tree in temporary repo for: %s Error: %w", t.repo.FullName(), err)

if ref == "" {

ref = "HEAD"

}

if err != nil {

log.Error("Unable to get last ref for %s in temporary repo: %s(%s): Error: %v", ref, t.repo.FullName(), t.basePath, err)

return "", fmt.Errorf("Unable to rev-parse %s in temporary repo for: %s Error: %w", ref, t.repo.FullName(), err)

_, _ = messageBytes.WriteString(opts.CommitMessage)

_, _ = messageBytes.WriteString("\n")

if opts.ParentCommitID != "" {

cmdCommitTree.AddOptionValues("-p", opts.ParentCommitID)

}

stdout := new(bytes.Buffer)

stderr := new(bytes.Buffer)

if err := cmdCommitTree.

Env: env,

Dir: t.basePath,

Stdin: messageBytes,

}()

stderr := new(bytes.Buffer)

var diff *gitdiff.Diff

Timeout: 30 * time.Second,

Dir: t.basePath,

Stdout: stdoutWriter,

needsRollback = true

if opts.SingleBranch != "" {

cloneCmd.AddArguments("--single-branch", "--branch").AddDynamicArguments(opts.SingleBranch)

}

repoPath := repo_model.RepoPath(owner.Name, repo.Name)

if stdout, _, err := cloneCmd.AddDynamicArguments(oldRepoPath, repoPath).

log.Error("Fork Repository (git clone) Failed for %v (from %v):\nStdout: %s\nError: %v", repo, opts.BaseRepo, stdout, err)

return fmt.Errorf("git clone: %w", err)

}

return fmt.Errorf("checkDaemonExportOK: %w", err)

}

log.Error("Fork Repository (git update-server-info) failed for %v:\nStdout: %s\nError: %v", repo, stdout, err)

return fmt.Errorf("git update-server-info: %w", err)

}

return err

}

log.Error("Unable to add %v as remote origin to temporary repo to %s: stdout %s\nError: %v", repo, tmpDir, stdout, err)

return fmt.Errorf("git remote add: %w", err)

}

return generateRepo, fmt.Errorf("checkDaemonExportOK: %w", err)

}

log.Error("GenerateRepository(git update-server-info) in %v: Stdout: %s\nError: %v", generateRepo, stdout, err)

return generateRepo, fmt.Errorf("error in GenerateRepository(git update-server-info): %w", err)

}

page = 1

}

if hidePRRefs {

graphCmd.AddArguments("--exclude=" + git.PullPrefix + "*")

scanner := bufio.NewScanner(stdoutReader)

Dir: r.Path,

Stdout: stdoutWriter,

Stderr: stderr,

committerName := sig.Name

committerEmail := sig.Email

log.Error("git add --all failed: Stdout: %s\nError: %v", stdout, err)

return fmt.Errorf("git add --all: %w", err)

}

AddOptionFormat("--author='%s <%s>'", sig.Name, sig.Email)

sign, keyID, signer, _ := asymkey_service.SignInitialCommit(ctx, tmpPath, u)

)

if stdout, _, err := cmd.

log.Error("Failed to commit: %v: Stdout: %s\nError: %v", cmd.LogString(), stdout, err)

return fmt.Errorf("git commit: %w", err)

}

defaultBranch = setting.Repository.DefaultBranch

}

log.Error("Failed to push back to HEAD: Stdout: %s\nError: %v", stdout, err)

return fmt.Errorf("git push: %w", err)

}

return repo, fmt.Errorf("checkDaemonExportOK: %w", err)

}

log.Error("MigrateRepositoryGitData(git update-server-info) in %v: Stdout: %s\nError: %v", repo, stdout, err)

return repo, fmt.Errorf("error in MigrateRepositoryGitData(git update-server-info): %w", err)

}

// this is necessary for sync local tags from remote

configName := fmt.Sprintf("remote.%s.fetch", mirrorModel.GetRemoteName())

AddOptionValues("--add", configName, `+refs/tags/*:refs/tags/*`).

log.Error("MigrateRepositoryGitData(git config --add <remote> +refs/tags/*:refs/tags/*) in %v: Stdout: %s\nError: %v", repo, stdout, err)

return repo, fmt.Errorf("error in MigrateRepositoryGitData(git config --add <remote> +refs/tags/*:refs/tags/*): %w", err)

}

// cleanUpMigrateGitConfig removes mirror info which prevents "push --all".

// This also removes possible user credentials.

func cleanUpMigrateGitConfig(ctx context.Context, repoPath string) error {

// if the origin does not exist

Dir: repoPath,

})

if err != nil && !git.IsRemoteNotExistError(err) {

}

}

if err != nil && !git.IsRemoteNotExistError(err) {

return repo, fmt.Errorf("CleanUpMigrateInfo: %w", err)

}

return fmt.Errorf("InitRepository: %w", err)

} else if err = repo_module.CreateDelegateHooks(repo.WikiPath()); err != nil {

return fmt.Errorf("createDelegateHooks: %w", err)

return fmt.Errorf("unable to set default wiki branch to %q: %w", repo.DefaultWikiBranch, err)

}

return nil