Use context parameter in services/repository (#23186)

Use context parameter in `services/repository`.

And use `cache.WithCacheContext(ctx)` to generate push action history
feeds.

Fix #23160

diff --git a/routers/api/v1/admin/adopt.go b/routers/api/v1/admin/adopt.go
index 0e4e498e98243b40e168ae1fd88d6cd79ff5e823..47fd0ef3c30cfe0e92b42dce5711b449387443e7 100644 (file)
--- a/routers/api/v1/admin/adopt.go
+++ b/routers/api/v1/admin/adopt.go
@@ -45,7 +45,7 @@ func ListUnadoptedRepositories(ctx *context.APIContext) {
        if listOptions.Page == 0 {
                listOptions.Page = 1
        }
-       repoNames, count, err := repo_service.ListUnadoptedRepositories(ctx.FormString("query"), &listOptions)
+       repoNames, count, err := repo_service.ListUnadoptedRepositories(ctx, ctx.FormString("query"), &listOptions)
        if err != nil {
                ctx.InternalServerError(err)
                return
@@ -109,7 +109,7 @@ func AdoptRepository(ctx *context.APIContext) {
                ctx.NotFound()
                return
        }
-       if _, err := repo_service.AdoptRepository(ctx.Doer, ctxUser, repo_module.CreateRepoOptions{
+       if _, err := repo_service.AdoptRepository(ctx, ctx.Doer, ctxUser, repo_module.CreateRepoOptions{
                Name:      repoName,
                IsPrivate: true,
        }); err != nil {
@@ -172,7 +172,7 @@ func DeleteUnadoptedRepository(ctx *context.APIContext) {
                return
        }
 
-       if err := repo_service.DeleteUnadoptedRepository(ctx.Doer, ctxUser, repoName); err != nil {
+       if err := repo_service.DeleteUnadoptedRepository(ctx, ctx.Doer, ctxUser, repoName); err != nil {
                ctx.InternalServerError(err)
                return
        }

diff --git a/routers/api/v1/repo/branch.go b/routers/api/v1/repo/branch.go
index 8acaeaffb4173ce454d52d502dc0d4ee2995de00..dff47fbcf15b728d7a6f6a4d2e9e4494d22d6277 100644 (file)
--- a/routers/api/v1/repo/branch.go
+++ b/routers/api/v1/repo/branch.go
@@ -118,7 +118,7 @@ func DeleteBranch(ctx *context.APIContext) {
 
        branchName := ctx.Params("*")
 
-       if err := repo_service.DeleteBranch(ctx.Doer, ctx.Repo.Repository, ctx.Repo.GitRepo, branchName); err != nil {
+       if err := repo_service.DeleteBranch(ctx, ctx.Doer, ctx.Repo.Repository, ctx.Repo.GitRepo, branchName); err != nil {
                switch {
                case git.IsErrBranchNotExist(err):
                        ctx.NotFound(err)

diff --git a/routers/api/v1/repo/pull.go b/routers/api/v1/repo/pull.go
index 84eebeb94dd7d21d22b6a28e08e902332cb6efe6..9b5ec0b3f8ed665e501f9ad61f58c4cd19572201 100644 (file)
--- a/routers/api/v1/repo/pull.go
+++ b/routers/api/v1/repo/pull.go
@@ -904,7 +904,7 @@ func MergePullRequest(ctx *context.APIContext) {
                        }
                        defer headRepo.Close()
                }
-               if err := repo_service.DeleteBranch(ctx.Doer, pr.HeadRepo, headRepo, pr.HeadBranch); err != nil {
+               if err := repo_service.DeleteBranch(ctx, ctx.Doer, pr.HeadRepo, headRepo, pr.HeadBranch); err != nil {
                        switch {
                        case git.IsErrBranchNotExist(err):
                                ctx.NotFound(err)

diff --git a/routers/api/v1/repo/repo.go b/routers/api/v1/repo/repo.go
index 0395198e209a39afd3e1d4d3b4c26b19a74bde56..2f32ea956f150c07267b22cff77fd2a839ab8898 100644 (file)
--- a/routers/api/v1/repo/repo.go
+++ b/routers/api/v1/repo/repo.go
@@ -230,7 +230,7 @@ func CreateUserRepo(ctx *context.APIContext, owner *user_model.User, opt api.Cre
        if opt.AutoInit && opt.Readme == "" {
                opt.Readme = "Default"
        }
-       repo, err := repo_service.CreateRepository(ctx.Doer, owner, repo_module.CreateRepoOptions{
+       repo, err := repo_service.CreateRepository(ctx, ctx.Doer, owner, repo_module.CreateRepoOptions{
                Name:          opt.Name,
                Description:   opt.Description,
                IssueLabels:   opt.IssueLabels,
@@ -393,7 +393,7 @@ func Generate(ctx *context.APIContext) {
                }
        }
 
-       repo, err := repo_service.GenerateRepository(ctx.Doer, ctxUser, ctx.Repo.Repository, opts)
+       repo, err := repo_service.GenerateRepository(ctx, ctx.Doer, ctxUser, ctx.Repo.Repository, opts)
        if err != nil {
                if repo_model.IsErrRepoAlreadyExist(err) {
                        ctx.Error(http.StatusConflict, "", "The repository with the same name already exists.")
@@ -637,7 +637,7 @@ func updateBasicProperties(ctx *context.APIContext, opts api.EditRepoOption) err
        }
        // Check if repository name has been changed and not just a case change
        if repo.LowerName != strings.ToLower(newRepoName) {
-               if err := repo_service.ChangeRepositoryName(ctx.Doer, repo, newRepoName); err != nil {
+               if err := repo_service.ChangeRepositoryName(ctx, ctx.Doer, repo, newRepoName); err != nil {
                        switch {
                        case repo_model.IsErrRepoAlreadyExist(err):
                                ctx.Error(http.StatusUnprocessableEntity, fmt.Sprintf("repo name is already taken [name: %s]", newRepoName), err)
@@ -714,7 +714,7 @@ func updateBasicProperties(ctx *context.APIContext, opts api.EditRepoOption) err
                repo.DefaultBranch = *opts.DefaultBranch
        }
 
-       if err := repo_service.UpdateRepository(repo, visibilityChanged); err != nil {
+       if err := repo_service.UpdateRepository(ctx, repo, visibilityChanged); err != nil {
                ctx.Error(http.StatusInternalServerError, "UpdateRepository", err)
                return err
        }

diff --git a/routers/private/serv.go b/routers/private/serv.go
index 17f966e3e40a72f825371868db34dba570d41119..23ac011cf5a695d56f5e61d386464208f8ebff03 100644 (file)
--- a/routers/private/serv.go
+++ b/routers/private/serv.go
@@ -368,7 +368,7 @@ func ServCommand(ctx *context.PrivateContext) {
                        return
                }
 
-               repo, err = repo_service.PushCreateRepo(user, owner, results.RepoName)
+               repo, err = repo_service.PushCreateRepo(ctx, user, owner, results.RepoName)
                if err != nil {
                        log.Error("pushCreateRepo: %v", err)
                        ctx.JSON(http.StatusNotFound, private.ErrServCommand{

diff --git a/routers/web/admin/repos.go b/routers/web/admin/repos.go
index 1c4754f6d8a3e4442bdb03b264e4699cc98f5fed..53b609af966ba6c026e96eb9a01328d2bb0c013f 100644 (file)
--- a/routers/web/admin/repos.go
+++ b/routers/web/admin/repos.go
@@ -96,7 +96,7 @@ func UnadoptedRepos(ctx *context.Context) {
        }
 
        ctx.Data["Keyword"] = q
-       repoNames, count, err := repo_service.ListUnadoptedRepositories(q, &opts)
+       repoNames, count, err := repo_service.ListUnadoptedRepositories(ctx, q, &opts)
        if err != nil {
                ctx.ServerError("ListUnadoptedRepositories", err)
        }
@@ -148,7 +148,7 @@ func AdoptOrDeleteRepository(ctx *context.Context) {
        if has || !isDir {
                // Fallthrough to failure mode
        } else if action == "adopt" {
-               if _, err := repo_service.AdoptRepository(ctx.Doer, ctxUser, repo_module.CreateRepoOptions{
+               if _, err := repo_service.AdoptRepository(ctx, ctx.Doer, ctxUser, repo_module.CreateRepoOptions{
                        Name:      dirSplit[1],
                        IsPrivate: true,
                }); err != nil {
@@ -157,7 +157,7 @@ func AdoptOrDeleteRepository(ctx *context.Context) {
                }
                ctx.Flash.Success(ctx.Tr("repo.adopt_preexisting_success", dir))
        } else if action == "delete" {
-               if err := repo_service.DeleteUnadoptedRepository(ctx.Doer, ctxUser, dirSplit[1]); err != nil {
+               if err := repo_service.DeleteUnadoptedRepository(ctx, ctx.Doer, ctxUser, dirSplit[1]); err != nil {
                        ctx.ServerError("repository.AdoptRepository", err)
                        return
                }

diff --git a/routers/web/org/setting.go b/routers/web/org/setting.go
index 5c9b7967c3dc2b3a15bfd60b475c24841f206ad6..f713d096639bc398978ae570f00f994aee855c33 100644 (file)
--- a/routers/web/org/setting.go
+++ b/routers/web/org/setting.go
@@ -137,7 +137,7 @@ func SettingsPost(ctx *context.Context) {
                }
                for _, repo := range repos {
                        repo.OwnerName = org.Name
-                       if err := repo_service.UpdateRepository(repo, true); err != nil {
+                       if err := repo_service.UpdateRepository(ctx, repo, true); err != nil {
                                ctx.ServerError("UpdateRepository", err)
                                return
                        }

diff --git a/routers/web/repo/branch.go b/routers/web/repo/branch.go
index b34ccf8538553a1b24a279a096872d8a09525cee..d23367e04790d190ab32df9997f11715ba45837f 100644 (file)
--- a/routers/web/repo/branch.go
+++ b/routers/web/repo/branch.go
@@ -91,7 +91,7 @@ func DeleteBranchPost(ctx *context.Context) {
        defer redirect(ctx)
        branchName := ctx.FormString("name")
 
-       if err := repo_service.DeleteBranch(ctx.Doer, ctx.Repo.Repository, ctx.Repo.GitRepo, branchName); err != nil {
+       if err := repo_service.DeleteBranch(ctx, ctx.Doer, ctx.Repo.Repository, ctx.Repo.GitRepo, branchName); err != nil {
                switch {
                case git.IsErrBranchNotExist(err):
                        log.Debug("DeleteBranch: Can't delete non existing branch '%s'", branchName)

diff --git a/routers/web/repo/http.go b/routers/web/repo/http.go
index 002843d103c9a7616109d4883d02c18856d4beac..cd32d99533dc277a7830909b9870f3bb4dfa22eb 100644 (file)
--- a/routers/web/repo/http.go
+++ b/routers/web/repo/http.go
@@ -276,7 +276,7 @@ func httpBase(ctx *context.Context) (h *serviceHandler) {
                        return
                }
 
-               repo, err = repo_service.PushCreateRepo(ctx.Doer, owner, reponame)
+               repo, err = repo_service.PushCreateRepo(ctx, ctx.Doer, owner, reponame)
                if err != nil {
                        log.Error("pushCreateRepo: %v", err)
                        ctx.Status(http.StatusNotFound)

diff --git a/routers/web/repo/issue.go b/routers/web/repo/issue.go
index e4f94006155a2cee2b4d85a9447cf1d634f661c2..57575061ae535e1f3cbb8b934852db5cc698eb39 100644 (file)
--- a/routers/web/repo/issue.go
+++ b/routers/web/repo/issue.go
@@ -589,7 +589,7 @@ func RetrieveRepoReviewers(ctx *context.Context, repo *repo_model.Repository, is
                        return
                }
 
-               teamReviewers, err = repo_service.GetReviewerTeams(repo)
+               teamReviewers, err = repo_service.GetReviewerTeams(ctx, repo)
                if err != nil {
                        ctx.ServerError("GetReviewerTeams", err)
                        return

diff --git a/routers/web/repo/pull.go b/routers/web/repo/pull.go
index 38b9f22cbf3dd633fadbe5b906f4dd3c020e6796..78c935a8c8b7d165e39dab1d5d47088ea0c2d31d 100644 (file)
--- a/routers/web/repo/pull.go
+++ b/routers/web/repo/pull.go
@@ -1399,7 +1399,7 @@ func CleanUpPullRequest(ctx *context.Context) {
 
 func deleteBranch(ctx *context.Context, pr *issues_model.PullRequest, gitRepo *git.Repository) {
        fullBranchName := pr.HeadRepo.FullName() + ":" + pr.HeadBranch
-       if err := repo_service.DeleteBranch(ctx.Doer, pr.HeadRepo, gitRepo, pr.HeadBranch); err != nil {
+       if err := repo_service.DeleteBranch(ctx, ctx.Doer, pr.HeadRepo, gitRepo, pr.HeadBranch); err != nil {
                switch {
                case git.IsErrBranchNotExist(err):
                        ctx.Flash.Error(ctx.Tr("repo.branch.deletion_failed", fullBranchName))

diff --git a/routers/web/repo/repo.go b/routers/web/repo/repo.go
index 9f2add1fe6de6e629b31a604a9ee4d03b271c2de..b4e7b5a46e2a75ec40477a3660afb60bb990c8e9 100644 (file)
--- a/routers/web/repo/repo.go
+++ b/routers/web/repo/repo.go
@@ -248,14 +248,14 @@ func CreatePost(ctx *context.Context) {
                        return
                }
 
-               repo, err = repo_service.GenerateRepository(ctx.Doer, ctxUser, templateRepo, opts)
+               repo, err = repo_service.GenerateRepository(ctx, ctx.Doer, ctxUser, templateRepo, opts)
                if err == nil {
                        log.Trace("Repository generated [%d]: %s/%s", repo.ID, ctxUser.Name, repo.Name)
                        ctx.Redirect(repo.Link())
                        return
                }
        } else {
-               repo, err = repo_service.CreateRepository(ctx.Doer, ctxUser, repo_module.CreateRepoOptions{
+               repo, err = repo_service.CreateRepository(ctx, ctx.Doer, ctxUser, repo_module.CreateRepoOptions{
                        Name:          form.RepoName,
                        Description:   form.Description,
                        Gitignores:    form.Gitignores,
@@ -302,7 +302,7 @@ func Action(ctx *context.Context) {
 
                ctx.Repo.Repository.Description = ctx.FormString("desc")
                ctx.Repo.Repository.Website = ctx.FormString("site")
-               err = repo_service.UpdateRepository(ctx.Repo.Repository, false)
+               err = repo_service.UpdateRepository(ctx, ctx.Repo.Repository, false)
        }
 
        if err != nil {

diff --git a/routers/web/repo/setting.go b/routers/web/repo/setting.go
index 387a917412f1e971abcb95cab48494056dca77fe..0c36503b3c4fcc90731cffbeef1a18dbbebc0968 100644 (file)
--- a/routers/web/repo/setting.go
+++ b/routers/web/repo/setting.go
@@ -134,7 +134,7 @@ func SettingsPost(ctx *context.Context) {
                                ctx.Repo.GitRepo.Close()
                                ctx.Repo.GitRepo = nil
                        }
-                       if err := repo_service.ChangeRepositoryName(ctx.Doer, repo, newRepoName); err != nil {
+                       if err := repo_service.ChangeRepositoryName(ctx, ctx.Doer, repo, newRepoName); err != nil {
                                ctx.Data["Err_RepoName"] = true
                                switch {
                                case repo_model.IsErrRepoAlreadyExist(err):
@@ -183,7 +183,7 @@ func SettingsPost(ctx *context.Context) {
                }
 
                repo.IsPrivate = form.Private
-               if err := repo_service.UpdateRepository(repo, visibilityChanged); err != nil {
+               if err := repo_service.UpdateRepository(ctx, repo, visibilityChanged); err != nil {
                        ctx.ServerError("UpdateRepository", err)
                        return
                }
@@ -541,7 +541,7 @@ func SettingsPost(ctx *context.Context) {
                        return
                }
                if repoChanged {
-                       if err := repo_service.UpdateRepository(repo, false); err != nil {
+                       if err := repo_service.UpdateRepository(ctx, repo, false); err != nil {
                                ctx.ServerError("UpdateRepository", err)
                                return
                        }
@@ -560,7 +560,7 @@ func SettingsPost(ctx *context.Context) {
                }
 
                if changed {
-                       if err := repo_service.UpdateRepository(repo, false); err != nil {
+                       if err := repo_service.UpdateRepository(ctx, repo, false); err != nil {
                                ctx.ServerError("UpdateRepository", err)
                                return
                        }
@@ -580,7 +580,7 @@ func SettingsPost(ctx *context.Context) {
                        repo.IsFsckEnabled = form.EnableHealthCheck
                }
 
-               if err := repo_service.UpdateRepository(repo, false); err != nil {
+               if err := repo_service.UpdateRepository(ctx, repo, false); err != nil {
                        ctx.ServerError("UpdateRepository", err)
                        return
                }
@@ -672,7 +672,7 @@ func SettingsPost(ctx *context.Context) {
                        return
                }
 
-               if err := repo_service.ConvertForkToNormalRepository(repo); err != nil {
+               if err := repo_service.ConvertForkToNormalRepository(ctx, repo); err != nil {
                        log.Error("Unable to convert repository %-v from fork. Error: %v", repo, err)
                        ctx.ServerError("Convert Fork", err)
                        return
@@ -1244,7 +1244,7 @@ func UpdateAvatarSetting(ctx *context.Context, form forms.AvatarForm) error {
        if !(st.IsImage() && !st.IsSvgImage()) {
                return errors.New(ctx.Tr("settings.uploaded_avatar_not_a_image"))
        }
-       if err = repo_service.UploadAvatar(ctxRepo, data); err != nil {
+       if err = repo_service.UploadAvatar(ctx, ctxRepo, data); err != nil {
                return fmt.Errorf("UploadAvatar: %w", err)
        }
        return nil
@@ -1264,7 +1264,7 @@ func SettingsAvatar(ctx *context.Context) {
 
 // SettingsDeleteAvatar delete repository avatar
 func SettingsDeleteAvatar(ctx *context.Context) {
-       if err := repo_service.DeleteAvatar(ctx.Repo.Repository); err != nil {
+       if err := repo_service.DeleteAvatar(ctx, ctx.Repo.Repository); err != nil {
                ctx.Flash.Error(fmt.Sprintf("DeleteAvatar: %v", err))
        }
        ctx.Redirect(ctx.Repo.RepoLink + "/settings")

diff --git a/routers/web/repo/setting_protected_branch.go b/routers/web/repo/setting_protected_branch.go
index 0a8c39fef0735199d1942cb19b85844bfa78c5e2..34e84c4656827647c1ed85bb9947bdfd139155b6 100644 (file)
--- a/routers/web/repo/setting_protected_branch.go
+++ b/routers/web/repo/setting_protected_branch.go
@@ -356,7 +356,7 @@ func RenameBranchPost(ctx *context.Context) {
                return
        }
 
-       msg, err := repository.RenameBranch(ctx.Repo.Repository, ctx.Doer, ctx.Repo.GitRepo, form.From, form.To)
+       msg, err := repository.RenameBranch(ctx, ctx.Repo.Repository, ctx.Doer, ctx.Repo.GitRepo, form.From, form.To)
        if err != nil {
                ctx.ServerError("RenameBranch", err)
                return

diff --git a/routers/web/user/setting/adopt.go b/routers/web/user/setting/adopt.go
index 844d6fa166a1d393ee37889672330445b43c51d4..c9995e7278c55515df5f24663abdc99ca8ed6d09 100644 (file)
--- a/routers/web/user/setting/adopt.go
+++ b/routers/web/user/setting/adopt.go
@@ -45,7 +45,7 @@ func AdoptOrDeleteRepository(ctx *context.Context) {
        if has || !isDir {
                // Fallthrough to failure mode
        } else if action == "adopt" && allowAdopt {
-               if _, err := repo_service.AdoptRepository(ctxUser, ctxUser, repo_module.CreateRepoOptions{
+               if _, err := repo_service.AdoptRepository(ctx, ctxUser, ctxUser, repo_module.CreateRepoOptions{
                        Name:      dir,
                        IsPrivate: true,
                }); err != nil {
@@ -54,7 +54,7 @@ func AdoptOrDeleteRepository(ctx *context.Context) {
                }
                ctx.Flash.Success(ctx.Tr("repo.adopt_preexisting_success", dir))
        } else if action == "delete" && allowDelete {
-               if err := repo_service.DeleteUnadoptedRepository(ctxUser, ctxUser, dir); err != nil {
+               if err := repo_service.DeleteUnadoptedRepository(ctx, ctxUser, ctxUser, dir); err != nil {
                        ctx.ServerError("repository.AdoptRepository", err)
                        return
                }

diff --git a/services/repository/adopt.go b/services/repository/adopt.go
index 280c4cc035a8ffaa25b9c7cd79d6c581dfe1d61c..94b2c3f3d573fdfa1e3294184f322ab142401afd 100644 (file)
--- a/services/repository/adopt.go
+++ b/services/repository/adopt.go
@@ -26,7 +26,7 @@ import (
 )
 
 // AdoptRepository adopts pre-existing repository files for the user/organization.
-func AdoptRepository(doer, u *user_model.User, opts repo_module.CreateRepoOptions) (*repo_model.Repository, error) {
+func AdoptRepository(ctx context.Context, doer, u *user_model.User, opts repo_module.CreateRepoOptions) (*repo_model.Repository, error) {
        if !doer.IsAdmin && !u.CanCreateRepo() {
                return nil, repo_model.ErrReachLimitOfRepo{
                        Limit: u.MaxRepoCreation,
@@ -53,7 +53,7 @@ func AdoptRepository(doer, u *user_model.User, opts repo_module.CreateRepoOption
                IsEmpty:                         !opts.AutoInit,
        }
 
-       if err := db.WithTx(db.DefaultContext, func(ctx context.Context) error {
+       if err := db.WithTx(ctx, func(ctx context.Context) error {
                repoPath := repo_model.RepoPath(u.Name, repo.Name)
                isExist, err := util.IsExist(repoPath)
                if err != nil {
@@ -95,7 +95,7 @@ func AdoptRepository(doer, u *user_model.User, opts repo_module.CreateRepoOption
                return nil, err
        }
 
-       notification.NotifyCreateRepository(db.DefaultContext, doer, u, repo)
+       notification.NotifyCreateRepository(ctx, doer, u, repo)
 
        return repo, nil
 }
@@ -188,7 +188,7 @@ func adoptRepository(ctx context.Context, repoPath string, u *user_model.User, r
 }
 
 // DeleteUnadoptedRepository deletes unadopted repository files from the filesystem
-func DeleteUnadoptedRepository(doer, u *user_model.User, repoName string) error {
+func DeleteUnadoptedRepository(ctx context.Context, doer, u *user_model.User, repoName string) error {
        if err := repo_model.IsUsableRepoName(repoName); err != nil {
                return err
        }
@@ -206,7 +206,7 @@ func DeleteUnadoptedRepository(doer, u *user_model.User, repoName string) error
                }
        }
 
-       if exist, err := repo_model.IsRepositoryExist(db.DefaultContext, u, repoName); err != nil {
+       if exist, err := repo_model.IsRepositoryExist(ctx, u, repoName); err != nil {
                return err
        } else if exist {
                return repo_model.ErrRepoAlreadyExist{
@@ -232,11 +232,11 @@ func (unadopted *unadoptedRepositories) add(repository string) {
        unadopted.index++
 }
 
-func checkUnadoptedRepositories(userName string, repoNamesToCheck []string, unadopted *unadoptedRepositories) error {
+func checkUnadoptedRepositories(ctx context.Context, userName string, repoNamesToCheck []string, unadopted *unadoptedRepositories) error {
        if len(repoNamesToCheck) == 0 {
                return nil
        }
-       ctxUser, err := user_model.GetUserByName(db.DefaultContext, userName)
+       ctxUser, err := user_model.GetUserByName(ctx, userName)
        if err != nil {
                if user_model.IsErrUserNotExist(err) {
                        log.Debug("Missing user: %s", userName)
@@ -271,7 +271,7 @@ func checkUnadoptedRepositories(userName string, repoNamesToCheck []string, unad
 }
 
 // ListUnadoptedRepositories lists all the unadopted repositories that match the provided query
-func ListUnadoptedRepositories(query string, opts *db.ListOptions) ([]string, int, error) {
+func ListUnadoptedRepositories(ctx context.Context, query string, opts *db.ListOptions) ([]string, int, error) {
        globUser, _ := glob.Compile("*")
        globRepo, _ := glob.Compile("*")
 
@@ -315,7 +315,7 @@ func ListUnadoptedRepositories(query string, opts *db.ListOptions) ([]string, in
 
                if !strings.ContainsRune(path[len(root)+1:], filepath.Separator) {
                        // Got a new user
-                       if err = checkUnadoptedRepositories(userName, repoNamesToCheck, unadopted); err != nil {
+                       if err = checkUnadoptedRepositories(ctx, userName, repoNamesToCheck, unadopted); err != nil {
                                return err
                        }
                        repoNamesToCheck = repoNamesToCheck[:0]
@@ -338,7 +338,7 @@ func ListUnadoptedRepositories(query string, opts *db.ListOptions) ([]string, in
 
                repoNamesToCheck = append(repoNamesToCheck, name)
                if len(repoNamesToCheck) >= setting.Database.IterateBufferSize {
-                       if err = checkUnadoptedRepositories(userName, repoNamesToCheck, unadopted); err != nil {
+                       if err = checkUnadoptedRepositories(ctx, userName, repoNamesToCheck, unadopted); err != nil {
                                return err
                        }
                        repoNamesToCheck = repoNamesToCheck[:0]
@@ -349,7 +349,7 @@ func ListUnadoptedRepositories(query string, opts *db.ListOptions) ([]string, in
                return nil, 0, err
        }
 
-       if err := checkUnadoptedRepositories(userName, repoNamesToCheck, unadopted); err != nil {
+       if err := checkUnadoptedRepositories(ctx, userName, repoNamesToCheck, unadopted); err != nil {
                return nil, 0, err
        }
 

diff --git a/services/repository/adopt_test.go b/services/repository/adopt_test.go
index be8897693eb8f1eda20e6f4349e15446943c234b..3f777c425fb1516fc891bc33b0c4c9f89a8fc435 100644 (file)
--- a/services/repository/adopt_test.go
+++ b/services/repository/adopt_test.go
@@ -39,7 +39,7 @@ func TestCheckUnadoptedRepositories(t *testing.T) {
        // Non existent user
        //
        unadopted := &unadoptedRepositories{start: 0, end: 100}
-       err := checkUnadoptedRepositories("notauser", []string{"repo"}, unadopted)
+       err := checkUnadoptedRepositories(db.DefaultContext, "notauser", []string{"repo"}, unadopted)
        assert.NoError(t, err)
        assert.Equal(t, 0, len(unadopted.repositories))
        //
@@ -50,14 +50,14 @@ func TestCheckUnadoptedRepositories(t *testing.T) {
        repoName := "repo2"
        unadoptedRepoName := "unadopted"
        unadopted = &unadoptedRepositories{start: 0, end: 100}
-       err = checkUnadoptedRepositories(userName, []string{repoName, unadoptedRepoName}, unadopted)
+       err = checkUnadoptedRepositories(db.DefaultContext, userName, []string{repoName, unadoptedRepoName}, unadopted)
        assert.NoError(t, err)
        assert.Equal(t, []string{path.Join(userName, unadoptedRepoName)}, unadopted.repositories)
        //
        // Existing (adopted) repository is not returned
        //
        unadopted = &unadoptedRepositories{start: 0, end: 100}
-       err = checkUnadoptedRepositories(userName, []string{repoName}, unadopted)
+       err = checkUnadoptedRepositories(db.DefaultContext, userName, []string{repoName}, unadopted)
        assert.NoError(t, err)
        assert.Equal(t, 0, len(unadopted.repositories))
        assert.Equal(t, 0, unadopted.index)
@@ -72,13 +72,13 @@ func TestListUnadoptedRepositories_ListOptions(t *testing.T) {
        }
 
        opts := db.ListOptions{Page: 1, PageSize: 1}
-       repoNames, count, err := ListUnadoptedRepositories("", &opts)
+       repoNames, count, err := ListUnadoptedRepositories(db.DefaultContext, "", &opts)
        assert.NoError(t, err)
        assert.Equal(t, 2, count)
        assert.Equal(t, unadoptedList[0], repoNames[0])
 
        opts = db.ListOptions{Page: 2, PageSize: 1}
-       repoNames, count, err = ListUnadoptedRepositories("", &opts)
+       repoNames, count, err = ListUnadoptedRepositories(db.DefaultContext, "", &opts)
        assert.NoError(t, err)
        assert.Equal(t, 2, count)
        assert.Equal(t, unadoptedList[1], repoNames[0])

diff --git a/services/repository/avatar.go b/services/repository/avatar.go
index 5fe8bd2c72f886595142b777456c2700de2d36e1..74e5de877e0cacca8437c9331aa2fc4ab9b8be35 100644 (file)
--- a/services/repository/avatar.go
+++ b/services/repository/avatar.go
@@ -20,7 +20,7 @@ import (
 
 // UploadAvatar saves custom avatar for repository.
 // FIXME: split uploads to different subdirs in case we have massive number of repos.
-func UploadAvatar(repo *repo_model.Repository, data []byte) error {
+func UploadAvatar(ctx context.Context, repo *repo_model.Repository, data []byte) error {
        m, err := avatar.Prepare(data)
        if err != nil {
                return err
@@ -31,7 +31,7 @@ func UploadAvatar(repo *repo_model.Repository, data []byte) error {
                return nil
        }
 
-       ctx, committer, err := db.TxContext(db.DefaultContext)
+       ctx, committer, err := db.TxContext(ctx)
        if err != nil {
                return err
        }
@@ -65,7 +65,7 @@ func UploadAvatar(repo *repo_model.Repository, data []byte) error {
 }
 
 // DeleteAvatar deletes the repos's custom avatar.
-func DeleteAvatar(repo *repo_model.Repository) error {
+func DeleteAvatar(ctx context.Context, repo *repo_model.Repository) error {
        // Avatar not exists
        if len(repo.Avatar) == 0 {
                return nil
@@ -74,7 +74,7 @@ func DeleteAvatar(repo *repo_model.Repository) error {
        avatarPath := repo.CustomAvatarRelativePath()
        log.Trace("DeleteAvatar[%d]: %s", repo.ID, avatarPath)
 
-       ctx, committer, err := db.TxContext(db.DefaultContext)
+       ctx, committer, err := db.TxContext(ctx)
        if err != nil {
                return err
        }
@@ -102,7 +102,7 @@ func RemoveRandomAvatars(ctx context.Context) error {
                }
                stringifiedID := strconv.FormatInt(repository.ID, 10)
                if repository.Avatar == stringifiedID {
-                       return DeleteAvatar(repository)
+                       return DeleteAvatar(ctx, repository)
                }
                return nil
        })

diff --git a/services/repository/avatar_test.go b/services/repository/avatar_test.go
index 5ec899ec3f9a73f33f02288c11f7395a901bc744..4a0ba618538959a48c7540fe91f64cf6c72c5692 100644 (file)
--- a/services/repository/avatar_test.go
+++ b/services/repository/avatar_test.go
@@ -9,6 +9,7 @@ import (
        "image/png"
        "testing"
 
+       "code.gitea.io/gitea/models/db"
        repo_model "code.gitea.io/gitea/models/repo"
        "code.gitea.io/gitea/models/unittest"
        "code.gitea.io/gitea/modules/avatar"
@@ -25,7 +26,7 @@ func TestUploadAvatar(t *testing.T) {
        assert.NoError(t, unittest.PrepareTestDatabase())
        repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 10})
 
-       err := UploadAvatar(repo, buff.Bytes())
+       err := UploadAvatar(db.DefaultContext, repo, buff.Bytes())
        assert.NoError(t, err)
        assert.Equal(t, avatar.HashAvatar(10, buff.Bytes()), repo.Avatar)
 }
@@ -39,7 +40,7 @@ func TestUploadBigAvatar(t *testing.T) {
        assert.NoError(t, unittest.PrepareTestDatabase())
        repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 10})
 
-       err := UploadAvatar(repo, buff.Bytes())
+       err := UploadAvatar(db.DefaultContext, repo, buff.Bytes())
        assert.Error(t, err)
 }
 
@@ -52,10 +53,10 @@ func TestDeleteAvatar(t *testing.T) {
        assert.NoError(t, unittest.PrepareTestDatabase())
        repo := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 10})
 
-       err := UploadAvatar(repo, buff.Bytes())
+       err := UploadAvatar(db.DefaultContext, repo, buff.Bytes())
        assert.NoError(t, err)
 
-       err = DeleteAvatar(repo)
+       err = DeleteAvatar(db.DefaultContext, repo)
        assert.NoError(t, err)
 
        assert.Equal(t, "", repo.Avatar)

diff --git a/services/repository/branch.go b/services/repository/branch.go
index 291fb4a92b374f4d03e82a5649f4006462e2c6c9..a085026ae1563820d99ddfd8c2741b5c5b05310d 100644 (file)
--- a/services/repository/branch.go
+++ b/services/repository/branch.go
@@ -10,7 +10,6 @@ import (
        "strings"
 
        "code.gitea.io/gitea/models"
-       "code.gitea.io/gitea/models/db"
        git_model "code.gitea.io/gitea/models/git"
        repo_model "code.gitea.io/gitea/models/repo"
        user_model "code.gitea.io/gitea/models/user"
@@ -106,7 +105,7 @@ func CreateNewBranchFromCommit(ctx context.Context, doer *user_model.User, repo
 }
 
 // RenameBranch rename a branch
-func RenameBranch(repo *repo_model.Repository, doer *user_model.User, gitRepo *git.Repository, from, to string) (string, error) {
+func RenameBranch(ctx context.Context, repo *repo_model.Repository, doer *user_model.User, gitRepo *git.Repository, from, to string) (string, error) {
        if from == to {
                return "target_exist", nil
        }
@@ -119,7 +118,7 @@ func RenameBranch(repo *repo_model.Repository, doer *user_model.User, gitRepo *g
                return "from_not_exist", nil
        }
 
-       if err := git_model.RenameBranch(db.DefaultContext, repo, from, to, func(isDefault bool) error {
+       if err := git_model.RenameBranch(ctx, repo, from, to, func(isDefault bool) error {
                err2 := gitRepo.RenameBranch(from, to)
                if err2 != nil {
                        return err2
@@ -141,8 +140,8 @@ func RenameBranch(repo *repo_model.Repository, doer *user_model.User, gitRepo *g
                return "", err
        }
 
-       notification.NotifyDeleteRef(db.DefaultContext, doer, repo, "branch", git.BranchPrefix+from)
-       notification.NotifyCreateRef(db.DefaultContext, doer, repo, "branch", git.BranchPrefix+to, refID)
+       notification.NotifyDeleteRef(ctx, doer, repo, "branch", git.BranchPrefix+from)
+       notification.NotifyCreateRef(ctx, doer, repo, "branch", git.BranchPrefix+to, refID)
 
        return "", nil
 }
@@ -153,12 +152,12 @@ var (
 )
 
 // DeleteBranch delete branch
-func DeleteBranch(doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, branchName string) error {
+func DeleteBranch(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, gitRepo *git.Repository, branchName string) error {
        if branchName == repo.DefaultBranch {
                return ErrBranchIsDefault
        }
 
-       isProtected, err := git_model.IsBranchProtected(db.DefaultContext, repo.ID, branchName)
+       isProtected, err := git_model.IsBranchProtected(ctx, repo.ID, branchName)
        if err != nil {
                return err
        }
@@ -195,7 +194,7 @@ func DeleteBranch(doer *user_model.User, repo *repo_model.Repository, gitRepo *g
                log.Error("Update: %v", err)
        }
 
-       if err := git_model.AddDeletedBranch(db.DefaultContext, repo.ID, branchName, commit.ID.String(), doer.ID); err != nil {
+       if err := git_model.AddDeletedBranch(ctx, repo.ID, branchName, commit.ID.String(), doer.ID); err != nil {
                log.Warn("AddDeletedBranch: %v", err)
        }
 

diff --git a/services/repository/fork.go b/services/repository/fork.go
index c3ca89e02e7f8ccea5aa541402ec7742733e3905..fb93b10f1c3124563a48bf2681904e3c340ee333 100644 (file)
--- a/services/repository/fork.go
+++ b/services/repository/fork.go
@@ -189,8 +189,8 @@ func ForkRepository(ctx context.Context, doer, owner *user_model.User, opts Fork
 }
 
 // ConvertForkToNormalRepository convert the provided repo from a forked repo to normal repo
-func ConvertForkToNormalRepository(repo *repo_model.Repository) error {
-       err := db.WithTx(db.DefaultContext, func(ctx context.Context) error {
+func ConvertForkToNormalRepository(ctx context.Context, repo *repo_model.Repository) error {
+       err := db.WithTx(ctx, func(ctx context.Context) error {
                repo, err := repo_model.GetRepositoryByID(ctx, repo.ID)
                if err != nil {
                        return err

diff --git a/services/repository/push.go b/services/repository/push.go
index 8aa8be6aa2fd608f1debe94fe034dd3078245d75..355c2878113fdd8a1d717ea566130c95d9847b1d 100644 (file)
--- a/services/repository/push.go
+++ b/services/repository/push.go
@@ -80,6 +80,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
 
        ctx, _, finished := process.GetManager().AddContext(graceful.GetManager().HammerContext(), fmt.Sprintf("PushUpdates: %s/%s", optsList[0].RepoUserName, optsList[0].RepoName))
        defer finished()
+       ctx = cache.WithCacheContext(ctx)
 
        repo, err := repo_model.GetRepositoryByOwnerAndName(ctx, optsList[0].RepoUserName, optsList[0].RepoName)
        if err != nil {
@@ -122,7 +123,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                        tagName := opts.TagName()
                        if opts.IsDelRef() {
                                notification.NotifyPushCommits(
-                                       db.DefaultContext, pusher, repo,
+                                       ctx, pusher, repo,
                                        &repo_module.PushUpdateOptions{
                                                RefFullName: git.TagPrefix + tagName,
                                                OldCommitID: opts.OldCommitID,
@@ -130,7 +131,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                                        }, repo_module.NewPushCommits())
 
                                delTags = append(delTags, tagName)
-                               notification.NotifyDeleteRef(db.DefaultContext, pusher, repo, "tag", opts.RefFullName)
+                               notification.NotifyDeleteRef(ctx, pusher, repo, "tag", opts.RefFullName)
                        } else { // is new tag
                                newCommit, err := gitRepo.GetCommit(opts.NewCommitID)
                                if err != nil {
@@ -142,7 +143,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                                commits.CompareURL = repo.ComposeCompareURL(git.EmptySHA, opts.NewCommitID)
 
                                notification.NotifyPushCommits(
-                                       db.DefaultContext, pusher, repo,
+                                       ctx, pusher, repo,
                                        &repo_module.PushUpdateOptions{
                                                RefFullName: git.TagPrefix + tagName,
                                                OldCommitID: git.EmptySHA,
@@ -150,7 +151,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                                        }, commits)
 
                                addTags = append(addTags, tagName)
-                               notification.NotifyCreateRef(db.DefaultContext, pusher, repo, "tag", opts.RefFullName, opts.NewCommitID)
+                               notification.NotifyCreateRef(ctx, pusher, repo, "tag", opts.RefFullName, opts.NewCommitID)
                        }
                } else if opts.IsBranch() { // If is branch reference
                        if pusher == nil || pusher.ID != opts.PusherID {
@@ -190,7 +191,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                                                        }
                                                }
                                                // Update the is empty and default_branch columns
-                                               if err := repo_model.UpdateRepositoryCols(db.DefaultContext, repo, "default_branch", "is_empty"); err != nil {
+                                               if err := repo_model.UpdateRepositoryCols(ctx, repo, "default_branch", "is_empty"); err != nil {
                                                        return fmt.Errorf("UpdateRepositoryCols: %w", err)
                                                }
                                        }
@@ -199,7 +200,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                                        if err != nil {
                                                return fmt.Errorf("newCommit.CommitsBeforeLimit: %w", err)
                                        }
-                                       notification.NotifyCreateRef(db.DefaultContext, pusher, repo, "branch", opts.RefFullName, opts.NewCommitID)
+                                       notification.NotifyCreateRef(ctx, pusher, repo, "branch", opts.RefFullName, opts.NewCommitID)
                                } else {
                                        l, err = newCommit.CommitsBeforeUntil(opts.OldCommitID)
                                        if err != nil {
@@ -259,7 +260,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                                        commits.Commits = commits.Commits[:setting.UI.FeedMaxCommitNum]
                                }
 
-                               notification.NotifyPushCommits(db.DefaultContext, pusher, repo, opts, commits)
+                               notification.NotifyPushCommits(ctx, pusher, repo, opts, commits)
 
                                if err = git_model.RemoveDeletedBranchByName(ctx, repo.ID, branch); err != nil {
                                        log.Error("models.RemoveDeletedBranch %s/%s failed: %v", repo.ID, branch, err)
@@ -270,7 +271,7 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                                        log.Error("repo_module.CacheRef %s/%s failed: %v", repo.ID, branch, err)
                                }
                        } else {
-                               notification.NotifyDeleteRef(db.DefaultContext, pusher, repo, "branch", opts.RefFullName)
+                               notification.NotifyDeleteRef(ctx, pusher, repo, "branch", opts.RefFullName)
                                if err = pull_service.CloseBranchPulls(pusher, repo.ID, branch); err != nil {
                                        // close all related pulls
                                        log.Error("close related pull request failed: %v", err)
@@ -278,14 +279,14 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
                        }
 
                        // Even if user delete a branch on a repository which he didn't watch, he will be watch that.
-                       if err = repo_model.WatchIfAuto(db.DefaultContext, opts.PusherID, repo.ID, true); err != nil {
+                       if err = repo_model.WatchIfAuto(ctx, opts.PusherID, repo.ID, true); err != nil {
                                log.Warn("Fail to perform auto watch on user %v for repo %v: %v", opts.PusherID, repo.ID, err)
                        }
                } else {
                        log.Trace("Non-tag and non-branch commits pushed.")
                }
        }
-       if err := PushUpdateAddDeleteTags(repo, gitRepo, addTags, delTags); err != nil {
+       if err := PushUpdateAddDeleteTags(ctx, repo, gitRepo, addTags, delTags); err != nil {
                return fmt.Errorf("PushUpdateAddDeleteTags: %w", err)
        }
 
@@ -298,8 +299,8 @@ func pushUpdates(optsList []*repo_module.PushUpdateOptions) error {
 }
 
 // PushUpdateAddDeleteTags updates a number of added and delete tags
-func PushUpdateAddDeleteTags(repo *repo_model.Repository, gitRepo *git.Repository, addTags, delTags []string) error {
-       return db.WithTx(db.DefaultContext, func(ctx context.Context) error {
+func PushUpdateAddDeleteTags(ctx context.Context, repo *repo_model.Repository, gitRepo *git.Repository, addTags, delTags []string) error {
+       return db.WithTx(ctx, func(ctx context.Context) error {
                if err := repo_model.PushUpdateDeleteTagsContext(ctx, repo, delTags); err != nil {
                        return err
                }

diff --git a/services/repository/repository.go b/services/repository/repository.go
index 3c3e7e82c3f8ff234bb89754ceedc81c3c4b6c40..000b1a3da6bce9437aa9ba0e4156d563c2b71a9a 100644 (file)
--- a/services/repository/repository.go
+++ b/services/repository/repository.go
@@ -24,14 +24,14 @@ import (
 )
 
 // CreateRepository creates a repository for the user/organization.
-func CreateRepository(doer, owner *user_model.User, opts repo_module.CreateRepoOptions) (*repo_model.Repository, error) {
+func CreateRepository(ctx context.Context, doer, owner *user_model.User, opts repo_module.CreateRepoOptions) (*repo_model.Repository, error) {
        repo, err := repo_module.CreateRepository(doer, owner, opts)
        if err != nil {
                // No need to rollback here we should do this in CreateRepository...
                return nil, err
        }
 
-       notification.NotifyCreateRepository(db.DefaultContext, doer, owner, repo)
+       notification.NotifyCreateRepository(ctx, doer, owner, repo)
 
        return repo, nil
 }
@@ -55,10 +55,10 @@ func DeleteRepository(ctx context.Context, doer *user_model.User, repo *repo_mod
 }
 
 // PushCreateRepo creates a repository when a new repository is pushed to an appropriate namespace
-func PushCreateRepo(authUser, owner *user_model.User, repoName string) (*repo_model.Repository, error) {
+func PushCreateRepo(ctx context.Context, authUser, owner *user_model.User, repoName string) (*repo_model.Repository, error) {
        if !authUser.IsAdmin {
                if owner.IsOrganization() {
-                       if ok, err := organization.CanCreateOrgRepo(db.DefaultContext, owner.ID, authUser.ID); err != nil {
+                       if ok, err := organization.CanCreateOrgRepo(ctx, owner.ID, authUser.ID); err != nil {
                                return nil, err
                        } else if !ok {
                                return nil, fmt.Errorf("cannot push-create repository for org")
@@ -68,7 +68,7 @@ func PushCreateRepo(authUser, owner *user_model.User, repoName string) (*repo_mo
                }
        }
 
-       repo, err := CreateRepository(authUser, owner, repo_module.CreateRepoOptions{
+       repo, err := CreateRepository(ctx, authUser, owner, repo_module.CreateRepoOptions{
                Name:      repoName,
                IsPrivate: setting.Repository.DefaultPushCreatePrivate,
        })
@@ -88,8 +88,8 @@ func Init() error {
 }
 
 // UpdateRepository updates a repository
-func UpdateRepository(repo *repo_model.Repository, visibilityChanged bool) (err error) {
-       ctx, committer, err := db.TxContext(db.DefaultContext)
+func UpdateRepository(ctx context.Context, repo *repo_model.Repository, visibilityChanged bool) (err error) {
+       ctx, committer, err := db.TxContext(ctx)
        if err != nil {
                return err
        }

diff --git a/services/repository/review.go b/services/repository/review.go
index 6b5f096053214ed9d593577deb448e965fead206..40513e6bc67babd82de502493006733a7b62e243 100644 (file)
--- a/services/repository/review.go
+++ b/services/repository/review.go
@@ -4,20 +4,21 @@
 package repository
 
 import (
-       "code.gitea.io/gitea/models/db"
+       "context"
+
        "code.gitea.io/gitea/models/organization"
        "code.gitea.io/gitea/models/perm"
        repo_model "code.gitea.io/gitea/models/repo"
 )
 
 // GetReviewerTeams get all teams can be requested to review
-func GetReviewerTeams(repo *repo_model.Repository) ([]*organization.Team, error) {
-       if err := repo.LoadOwner(db.DefaultContext); err != nil {
+func GetReviewerTeams(ctx context.Context, repo *repo_model.Repository) ([]*organization.Team, error) {
+       if err := repo.LoadOwner(ctx); err != nil {
                return nil, err
        }
        if !repo.Owner.IsOrganization() {
                return nil, nil
        }
 
-       return organization.GetTeamsWithAccessToRepo(db.DefaultContext, repo.OwnerID, repo.ID, perm.AccessModeRead)
+       return organization.GetTeamsWithAccessToRepo(ctx, repo.OwnerID, repo.ID, perm.AccessModeRead)
 }

diff --git a/services/repository/review_test.go b/services/repository/review_test.go
index 2bf4cdbf5cdf215ec3637ac982e7d10c0473a60f..2db56d4e8a9cc1189e935d0e8c7b7a6a5c79fe76 100644 (file)
--- a/services/repository/review_test.go
+++ b/services/repository/review_test.go
@@ -6,6 +6,7 @@ package repository
 import (
        "testing"
 
+       "code.gitea.io/gitea/models/db"
        repo_model "code.gitea.io/gitea/models/repo"
        "code.gitea.io/gitea/models/unittest"
 
@@ -16,12 +17,12 @@ func TestRepoGetReviewerTeams(t *testing.T) {
        assert.NoError(t, unittest.PrepareTestDatabase())
 
        repo2 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 2})
-       teams, err := GetReviewerTeams(repo2)
+       teams, err := GetReviewerTeams(db.DefaultContext, repo2)
        assert.NoError(t, err)
        assert.Empty(t, teams)
 
        repo3 := unittest.AssertExistsAndLoadBean(t, &repo_model.Repository{ID: 3})
-       teams, err = GetReviewerTeams(repo3)
+       teams, err = GetReviewerTeams(db.DefaultContext, repo3)
        assert.NoError(t, err)
        assert.Len(t, teams, 2)
 }

diff --git a/services/repository/template.go b/services/repository/template.go
index 8c75948c418b81d79105ad730021fbfc81ff1423..42174d095b0354a1c5929e515906368828994160 100644 (file)
--- a/services/repository/template.go
+++ b/services/repository/template.go
@@ -40,7 +40,7 @@ func GenerateIssueLabels(ctx context.Context, templateRepo, generateRepo *repo_m
 }
 
 // GenerateRepository generates a repository from a template
-func GenerateRepository(doer, owner *user_model.User, templateRepo *repo_model.Repository, opts repo_module.GenerateRepoOptions) (_ *repo_model.Repository, err error) {
+func GenerateRepository(ctx context.Context, doer, owner *user_model.User, templateRepo *repo_model.Repository, opts repo_module.GenerateRepoOptions) (_ *repo_model.Repository, err error) {
        if !doer.IsAdmin && !owner.CanCreateRepo() {
                return nil, repo_model.ErrReachLimitOfRepo{
                        Limit: owner.MaxRepoCreation,
@@ -48,7 +48,7 @@ func GenerateRepository(doer, owner *user_model.User, templateRepo *repo_model.R
        }
 
        var generateRepo *repo_model.Repository
-       if err = db.WithTx(db.DefaultContext, func(ctx context.Context) error {
+       if err = db.WithTx(ctx, func(ctx context.Context) error {
                generateRepo, err = repo_module.GenerateRepository(ctx, doer, owner, templateRepo, opts)
                if err != nil {
                        return err
@@ -101,7 +101,7 @@ func GenerateRepository(doer, owner *user_model.User, templateRepo *repo_model.R
                return nil, err
        }
 
-       notification.NotifyCreateRepository(db.DefaultContext, doer, owner, generateRepo)
+       notification.NotifyCreateRepository(ctx, doer, owner, generateRepo)
 
        return generateRepo, nil
 }

diff --git a/services/repository/transfer.go b/services/repository/transfer.go
index 8c167552da06fa5c1e20bb416f1f22ce5c5a60b5..b9b26f314c2c38901b93cf1cfb154c8c62d0257a 100644 (file)
--- a/services/repository/transfer.go
+++ b/services/repository/transfer.go
@@ -8,7 +8,6 @@ import (
        "fmt"
 
        "code.gitea.io/gitea/models"
-       "code.gitea.io/gitea/models/db"
        "code.gitea.io/gitea/models/organization"
        "code.gitea.io/gitea/models/perm"
        access_model "code.gitea.io/gitea/models/perm/access"
@@ -61,7 +60,7 @@ func TransferOwnership(ctx context.Context, doer, newOwner *user_model.User, rep
 }
 
 // ChangeRepositoryName changes all corresponding setting from old repository name to new one.
-func ChangeRepositoryName(doer *user_model.User, repo *repo_model.Repository, newRepoName string) error {
+func ChangeRepositoryName(ctx context.Context, doer *user_model.User, repo *repo_model.Repository, newRepoName string) error {
        log.Trace("ChangeRepositoryName: %s/%s -> %s", doer.Name, repo.Name, newRepoName)
 
        oldRepoName := repo.Name
@@ -78,7 +77,7 @@ func ChangeRepositoryName(doer *user_model.User, repo *repo_model.Repository, ne
        repoWorkingPool.CheckOut(fmt.Sprint(repo.ID))
 
        repo.Name = newRepoName
-       notification.NotifyRenameRepository(db.DefaultContext, doer, repo, oldRepoName)
+       notification.NotifyRenameRepository(ctx, doer, repo, oldRepoName)
 
        return nil
 }

diff --git a/tests/integration/pull_merge_test.go b/tests/integration/pull_merge_test.go
index 090a27c39efbcf38ae4fb4a28eef111e302fedba..55cf295257a17ecf80412af93a6512f8f66ebd94 100644 (file)
--- a/tests/integration/pull_merge_test.go
+++ b/tests/integration/pull_merge_test.go
@@ -356,7 +356,7 @@ func TestConflictChecking(t *testing.T) {
                user := unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: 2})
 
                // Create new clean repo to test conflict checking.
-               baseRepo, err := repo_service.CreateRepository(user, user, repo_module.CreateRepoOptions{
+               baseRepo, err := repo_service.CreateRepository(db.DefaultContext, user, user, repo_module.CreateRepoOptions{
                        Name:          "conflict-checking",
                        Description:   "Tempo repo",
                        AutoInit:      true,

diff --git a/tests/integration/pull_update_test.go b/tests/integration/pull_update_test.go
index bd416e5bcfac360ee94a91fd3354730c2eb22bb8..1b66656518a30df73dc6a7202cacaa58f37f3a04 100644 (file)
--- a/tests/integration/pull_update_test.go
+++ b/tests/integration/pull_update_test.go
@@ -80,7 +80,7 @@ func TestAPIPullUpdateByRebase(t *testing.T) {
 }
 
 func createOutdatedPR(t *testing.T, actor, forkOrg *user_model.User) *issues_model.PullRequest {
-       baseRepo, err := repo_service.CreateRepository(actor, actor, repo_module.CreateRepoOptions{
+       baseRepo, err := repo_service.CreateRepository(db.DefaultContext, actor, actor, repo_module.CreateRepoOptions{
                Name:        "repo-pr-update",
                Description: "repo-tmp-pr-update description",
                AutoInit:    true,