mirror of
https://codeberg.org/forgejo/forgejo
synced 2024-11-25 11:16:11 +01:00
f4538791f5
# Why this PR comes At first, I'd like to help users like #23636 (there are a lot) The unclear "Internal Server Error" is quite anonying, scare users, frustrate contributors, nobody knows what happens. So, it's always good to provide meaningful messages to end users (of course, do not leak sensitive information). When I started working on the "response message to end users", I found that the related code has a lot of technical debt. A lot of copy&paste code, unclear fields and usages. So I think it's good to make everything clear. # Tech Backgrounds Gitea has many sub-commands, some are used by admins, some are used by SSH servers or Git Hooks. Many sub-commands use "internal API" to communicate with Gitea web server. Before, Gitea server always use `StatusCode + Json "err" field` to return messages. * The CLI sub-commands: they expect to show all error related messages to site admin * The Serv/Hook sub-commands (for git clients): they could only show safe messages to end users, the error log could only be recorded by "SSHLog" to Gitea web server. In the old design, it assumes that: * If the StatusCode is 500 (in some functions), then the "err" field is error log, shouldn't be exposed to git client. * If the StatusCode is 40x, then the "err" field could be exposed. And some functions always read the "err" no matter what the StatusCode is. The old code is not strict, and it's difficult to distinguish the messages clearly and then output them correctly. # This PR To help to remove duplicate code and make everything clear, this PR introduces `ResponseExtra` and `requestJSONResp`. * `ResponseExtra` is a struct which contains "extra" information of a internal API response, including StatusCode, UserMsg, Error * `requestJSONResp` is a generic function which can be used for all cases to help to simplify the calls. * Remove all `map["err"]`, always use `private.Response{Err}` to construct error messages. * User messages and error messages are separated clearly, the `fail` and `handleCliResponseExtra` will output correct messages. * Replace all `Internal Server Error` messages with meaningful (still safe) messages. This PR saves more than 300 lines, while makes the git client messages more clear. Many gitea-serv/git-hook related essential functions are covered by tests. --------- Co-authored-by: delvh <dev.lh@web.de>
242 lines
8.1 KiB
Go
242 lines
8.1 KiB
Go
// Copyright 2021 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package private
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
issues_model "code.gitea.io/gitea/models/issues"
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
|
gitea_context "code.gitea.io/gitea/modules/context"
|
|
"code.gitea.io/gitea/modules/git"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/private"
|
|
repo_module "code.gitea.io/gitea/modules/repository"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
"code.gitea.io/gitea/modules/util"
|
|
"code.gitea.io/gitea/modules/web"
|
|
repo_service "code.gitea.io/gitea/services/repository"
|
|
)
|
|
|
|
// HookPostReceive updates services and users
|
|
func HookPostReceive(ctx *gitea_context.PrivateContext) {
|
|
opts := web.GetForm(ctx).(*private.HookOptions)
|
|
|
|
// We don't rely on RepoAssignment here because:
|
|
// a) we don't need the git repo in this function
|
|
// b) our update function will likely change the repository in the db so we will need to refresh it
|
|
// c) we don't always need the repo
|
|
|
|
ownerName := ctx.Params(":owner")
|
|
repoName := ctx.Params(":repo")
|
|
|
|
// defer getting the repository at this point - as we should only retrieve it if we're going to call update
|
|
var repo *repo_model.Repository
|
|
|
|
updates := make([]*repo_module.PushUpdateOptions, 0, len(opts.OldCommitIDs))
|
|
wasEmpty := false
|
|
|
|
for i := range opts.OldCommitIDs {
|
|
refFullName := opts.RefFullNames[i]
|
|
|
|
// Only trigger activity updates for changes to branches or
|
|
// tags. Updates to other refs (eg, refs/notes, refs/changes,
|
|
// or other less-standard refs spaces are ignored since there
|
|
// may be a very large number of them).
|
|
if strings.HasPrefix(refFullName, git.BranchPrefix) || strings.HasPrefix(refFullName, git.TagPrefix) {
|
|
if repo == nil {
|
|
repo = loadRepository(ctx, ownerName, repoName)
|
|
if ctx.Written() {
|
|
// Error handled in loadRepository
|
|
return
|
|
}
|
|
wasEmpty = repo.IsEmpty
|
|
}
|
|
|
|
option := &repo_module.PushUpdateOptions{
|
|
RefFullName: refFullName,
|
|
OldCommitID: opts.OldCommitIDs[i],
|
|
NewCommitID: opts.NewCommitIDs[i],
|
|
PusherID: opts.UserID,
|
|
PusherName: opts.UserName,
|
|
RepoUserName: ownerName,
|
|
RepoName: repoName,
|
|
}
|
|
updates = append(updates, option)
|
|
if repo.IsEmpty && option.IsBranch() && (option.BranchName() == "master" || option.BranchName() == "main") {
|
|
// put the master/main branch first
|
|
copy(updates[1:], updates)
|
|
updates[0] = option
|
|
}
|
|
}
|
|
}
|
|
|
|
if repo != nil && len(updates) > 0 {
|
|
if err := repo_service.PushUpdates(updates); err != nil {
|
|
log.Error("Failed to Update: %s/%s Total Updates: %d", ownerName, repoName, len(updates))
|
|
for i, update := range updates {
|
|
log.Error("Failed to Update: %s/%s Update: %d/%d: Branch: %s", ownerName, repoName, i, len(updates), update.BranchName())
|
|
}
|
|
log.Error("Failed to Update: %s/%s Error: %v", ownerName, repoName, err)
|
|
|
|
ctx.JSON(http.StatusInternalServerError, private.HookPostReceiveResult{
|
|
Err: fmt.Sprintf("Failed to Update: %s/%s Error: %v", ownerName, repoName, err),
|
|
})
|
|
return
|
|
}
|
|
}
|
|
|
|
// Handle Push Options
|
|
if len(opts.GitPushOptions) > 0 {
|
|
// load the repository
|
|
if repo == nil {
|
|
repo = loadRepository(ctx, ownerName, repoName)
|
|
if ctx.Written() {
|
|
// Error handled in loadRepository
|
|
return
|
|
}
|
|
wasEmpty = repo.IsEmpty
|
|
}
|
|
|
|
repo.IsPrivate = opts.GitPushOptions.Bool(private.GitPushOptionRepoPrivate, repo.IsPrivate)
|
|
repo.IsTemplate = opts.GitPushOptions.Bool(private.GitPushOptionRepoTemplate, repo.IsTemplate)
|
|
if err := repo_model.UpdateRepositoryCols(ctx, repo, "is_private", "is_template"); err != nil {
|
|
log.Error("Failed to Update: %s/%s Error: %v", ownerName, repoName, err)
|
|
ctx.JSON(http.StatusInternalServerError, private.HookPostReceiveResult{
|
|
Err: fmt.Sprintf("Failed to Update: %s/%s Error: %v", ownerName, repoName, err),
|
|
})
|
|
}
|
|
}
|
|
|
|
results := make([]private.HookPostReceiveBranchResult, 0, len(opts.OldCommitIDs))
|
|
|
|
// We have to reload the repo in case its state is changed above
|
|
repo = nil
|
|
var baseRepo *repo_model.Repository
|
|
|
|
// Now handle the pull request notification trailers
|
|
for i := range opts.OldCommitIDs {
|
|
refFullName := opts.RefFullNames[i]
|
|
newCommitID := opts.NewCommitIDs[i]
|
|
|
|
// post update for agit pull request
|
|
if git.SupportProcReceive && strings.HasPrefix(refFullName, git.PullPrefix) {
|
|
if repo == nil {
|
|
repo = loadRepository(ctx, ownerName, repoName)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
}
|
|
|
|
pullIndexStr := strings.TrimPrefix(refFullName, git.PullPrefix)
|
|
pullIndexStr = strings.Split(pullIndexStr, "/")[0]
|
|
pullIndex, _ := strconv.ParseInt(pullIndexStr, 10, 64)
|
|
if pullIndex <= 0 {
|
|
continue
|
|
}
|
|
|
|
pr, err := issues_model.GetPullRequestByIndex(ctx, repo.ID, pullIndex)
|
|
if err != nil && !issues_model.IsErrPullRequestNotExist(err) {
|
|
log.Error("Failed to get PR by index %v Error: %v", pullIndex, err)
|
|
ctx.JSON(http.StatusInternalServerError, private.Response{
|
|
Err: fmt.Sprintf("Failed to get PR by index %v Error: %v", pullIndex, err),
|
|
})
|
|
return
|
|
}
|
|
if pr == nil {
|
|
continue
|
|
}
|
|
|
|
results = append(results, private.HookPostReceiveBranchResult{
|
|
Message: setting.Git.PullRequestPushMessage && repo.AllowsPulls(),
|
|
Create: false,
|
|
Branch: "",
|
|
URL: fmt.Sprintf("%s/pulls/%d", repo.HTMLURL(), pr.Index),
|
|
})
|
|
continue
|
|
}
|
|
|
|
branch := git.RefEndName(opts.RefFullNames[i])
|
|
|
|
// If we've pushed a branch (and not deleted it)
|
|
if newCommitID != git.EmptySHA && strings.HasPrefix(refFullName, git.BranchPrefix) {
|
|
|
|
// First ensure we have the repository loaded, we're allowed pulls requests and we can get the base repo
|
|
if repo == nil {
|
|
repo = loadRepository(ctx, ownerName, repoName)
|
|
if ctx.Written() {
|
|
return
|
|
}
|
|
|
|
baseRepo = repo
|
|
|
|
if repo.IsFork {
|
|
if err := repo.GetBaseRepo(ctx); err != nil {
|
|
log.Error("Failed to get Base Repository of Forked repository: %-v Error: %v", repo, err)
|
|
ctx.JSON(http.StatusInternalServerError, private.HookPostReceiveResult{
|
|
Err: fmt.Sprintf("Failed to get Base Repository of Forked repository: %-v Error: %v", repo, err),
|
|
RepoWasEmpty: wasEmpty,
|
|
})
|
|
return
|
|
}
|
|
if repo.BaseRepo.AllowsPulls() {
|
|
baseRepo = repo.BaseRepo
|
|
}
|
|
}
|
|
|
|
if !baseRepo.AllowsPulls() {
|
|
// We can stop there's no need to go any further
|
|
ctx.JSON(http.StatusOK, private.HookPostReceiveResult{
|
|
RepoWasEmpty: wasEmpty,
|
|
})
|
|
return
|
|
}
|
|
}
|
|
|
|
// If our branch is the default branch of an unforked repo - there's no PR to create or refer to
|
|
if !repo.IsFork && branch == baseRepo.DefaultBranch {
|
|
results = append(results, private.HookPostReceiveBranchResult{})
|
|
continue
|
|
}
|
|
|
|
pr, err := issues_model.GetUnmergedPullRequest(ctx, repo.ID, baseRepo.ID, branch, baseRepo.DefaultBranch, issues_model.PullRequestFlowGithub)
|
|
if err != nil && !issues_model.IsErrPullRequestNotExist(err) {
|
|
log.Error("Failed to get active PR in: %-v Branch: %s to: %-v Branch: %s Error: %v", repo, branch, baseRepo, baseRepo.DefaultBranch, err)
|
|
ctx.JSON(http.StatusInternalServerError, private.HookPostReceiveResult{
|
|
Err: fmt.Sprintf(
|
|
"Failed to get active PR in: %-v Branch: %s to: %-v Branch: %s Error: %v", repo, branch, baseRepo, baseRepo.DefaultBranch, err),
|
|
RepoWasEmpty: wasEmpty,
|
|
})
|
|
return
|
|
}
|
|
|
|
if pr == nil {
|
|
if repo.IsFork {
|
|
branch = fmt.Sprintf("%s:%s", repo.OwnerName, branch)
|
|
}
|
|
results = append(results, private.HookPostReceiveBranchResult{
|
|
Message: setting.Git.PullRequestPushMessage && baseRepo.AllowsPulls(),
|
|
Create: true,
|
|
Branch: branch,
|
|
URL: fmt.Sprintf("%s/compare/%s...%s", baseRepo.HTMLURL(), util.PathEscapeSegments(baseRepo.DefaultBranch), util.PathEscapeSegments(branch)),
|
|
})
|
|
} else {
|
|
results = append(results, private.HookPostReceiveBranchResult{
|
|
Message: setting.Git.PullRequestPushMessage && baseRepo.AllowsPulls(),
|
|
Create: false,
|
|
Branch: branch,
|
|
URL: fmt.Sprintf("%s/pulls/%d", baseRepo.HTMLURL(), pr.Index),
|
|
})
|
|
}
|
|
}
|
|
}
|
|
ctx.JSON(http.StatusOK, private.HookPostReceiveResult{
|
|
Results: results,
|
|
RepoWasEmpty: wasEmpty,
|
|
})
|
|
}
|