chore: replace pkg/errors with cockroachdb/errors (#8098)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: unknwon <2946214+unknwon@users.noreply.github.com>

internal/database/access_tokens.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	gouuid "github.com/satori/go.uuid"
 	"gorm.io/gorm"
 

internal/database/actions.go

@@ -9,10 +9,10 @@ import (
 	"time"
 	"unicode"
 
+	"github.com/cockroachdb/errors"
 	"github.com/gogs/git-module"
 	api "github.com/gogs/go-gogs-client"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 	"gorm.io/gorm"
 	log "unknwon.dev/clog/v2"
 

internal/database/attachment.go

@@ -8,6 +8,7 @@ import (
 	"path"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	gouuid "github.com/satori/go.uuid"
 	"xorm.io/xorm"
 
@@ -58,19 +59,19 @@ func NewAttachment(name string, buf []byte, file multipart.File) (_ *Attachment,
 
 	localPath := attach.LocalPath()
 	if err = os.MkdirAll(path.Dir(localPath), os.ModePerm); err != nil {
-		return nil, fmt.Errorf("MkdirAll: %v", err)
+		return nil, errors.Newf("MkdirAll: %v", err)
 	}
 
 	fw, err := os.Create(localPath)
 	if err != nil {
-		return nil, fmt.Errorf("Create: %v", err)
+		return nil, errors.Newf("Create: %v", err)
 	}
 	defer fw.Close()
 
 	if _, err = fw.Write(buf); err != nil {
-		return nil, fmt.Errorf("write: %v", err)
+		return nil, errors.Newf("write: %v", err)
 	} else if _, err = io.Copy(fw, file); err != nil {
-		return nil, fmt.Errorf("copy: %v", err)
+		return nil, errors.Newf("copy: %v", err)
 	}
 
 	if _, err := x.Insert(attach); err != nil {

internal/database/backup.go

@@ -12,8 +12,8 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/cockroachdb/errors"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 	"gorm.io/gorm"
 	"gorm.io/gorm/schema"
 	log "unknwon.dev/clog/v2"
@@ -125,14 +125,14 @@ func dumpLegacyTables(ctx context.Context, dirPath string, verbose bool) error {
 		tableFile := filepath.Join(dirPath, tableName+".json")
 		f, err := os.Create(tableFile)
 		if err != nil {
-			return fmt.Errorf("create JSON file: %v", err)
+			return errors.Newf("create JSON file: %v", err)
 		}
 
 		if err = x.Context(ctx).Asc("id").Iterate(table, func(idx int, bean any) (err error) {
 			return jsoniter.NewEncoder(f).Encode(bean)
 		}); err != nil {
 			_ = f.Close()
-			return fmt.Errorf("dump table '%s': %v", tableName, err)
+			return errors.Newf("dump table '%s': %v", tableName, err)
 		}
 		_ = f.Close()
 	}
@@ -256,25 +256,25 @@ func importLegacyTables(ctx context.Context, dirPath string, verbose bool) error
 		}
 
 		if err := x.DropTables(table); err != nil {
-			return fmt.Errorf("drop table %q: %v", tableName, err)
+			return errors.Newf("drop table %q: %v", tableName, err)
 		} else if err = x.Sync2(table); err != nil {
-			return fmt.Errorf("sync table %q: %v", tableName, err)
+			return errors.Newf("sync table %q: %v", tableName, err)
 		}
 
 		f, err := os.Open(tableFile)
 		if err != nil {
-			return fmt.Errorf("open JSON file: %v", err)
+			return errors.Newf("open JSON file: %v", err)
 		}
 		rawTableName := x.TableName(table)
 		_, isInsertProcessor := table.(xorm.BeforeInsertProcessor)
 		scanner := bufio.NewScanner(f)
 		for scanner.Scan() {
 			if err = jsoniter.Unmarshal(scanner.Bytes(), table); err != nil {
-				return fmt.Errorf("unmarshal to struct: %v", err)
+				return errors.Newf("unmarshal to struct: %v", err)
 			}
 
 			if _, err = x.Insert(table); err != nil {
-				return fmt.Errorf("insert strcut: %v", err)
+				return errors.Newf("insert strcut: %v", err)
 			}
 
 			var meta struct {
@@ -307,7 +307,7 @@ func importLegacyTables(ctx context.Context, dirPath string, verbose bool) error
 			rawTableName := snakeMapper.Obj2Table(tableName)
 			seqName := rawTableName + "_id_seq"
 			if _, err = x.Exec(fmt.Sprintf(`SELECT setval('%s', COALESCE((SELECT MAX(id)+1 FROM "%s"), 1), false);`, seqName, rawTableName)); err != nil {
-				return fmt.Errorf("reset table %q' sequence: %v", rawTableName, err)
+				return errors.Newf("reset table %q' sequence: %v", rawTableName, err)
 			}
 		}
 	}

internal/database/backup_test.go

@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
 

internal/database/comment.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/unknwon/com"
 	log "unknwon.dev/clog/v2"
 	"xorm.io/xorm"
@@ -97,7 +98,7 @@ func (c *Comment) loadAttributes(e Engine) (err error) {
 				c.PosterID = -1
 				c.Poster = NewGhostUser()
 			} else {
-				return fmt.Errorf("getUserByID.(Poster) [%d]: %v", c.PosterID, err)
+				return errors.Newf("getUserByID.(Poster) [%d]: %v", c.PosterID, err)
 			}
 		}
 	}
@@ -105,12 +106,12 @@ func (c *Comment) loadAttributes(e Engine) (err error) {
 	if c.Issue == nil {
 		c.Issue, err = getRawIssueByID(e, c.IssueID)
 		if err != nil {
-			return fmt.Errorf("getIssueByID [%d]: %v", c.IssueID, err)
+			return errors.Newf("getIssueByID [%d]: %v", c.IssueID, err)
 		}
 		if c.Issue.Repo == nil {
 			c.Issue.Repo, err = getRepositoryByID(e, c.Issue.RepoID)
 			if err != nil {
-				return fmt.Errorf("getRepositoryByID [%d]: %v", c.Issue.RepoID, err)
+				return errors.Newf("getRepositoryByID [%d]: %v", c.Issue.RepoID, err)
 			}
 		}
 	}
@@ -118,7 +119,7 @@ func (c *Comment) loadAttributes(e Engine) (err error) {
 	if c.Attachments == nil {
 		c.Attachments, err = getAttachmentsByCommentID(e, c.ID)
 		if err != nil {
-			return fmt.Errorf("getAttachmentsByCommentID [%d]: %v", c.ID, err)
+			return errors.Newf("getAttachmentsByCommentID [%d]: %v", c.ID, err)
 		}
 	}
 
@@ -165,7 +166,7 @@ func (c *Comment) EventTag() string {
 func (c *Comment) mailParticipants(e Engine, opType ActionType, issue *Issue) (err error) {
 	mentions := markup.FindAllMentions(c.Content)
 	if err = updateIssueMentions(e, c.IssueID, mentions); err != nil {
-		return fmt.Errorf("UpdateIssueMentions [%d]: %v", c.IssueID, err)
+		return errors.Newf("UpdateIssueMentions [%d]: %v", c.IssueID, err)
 	}
 
 	switch opType {
@@ -227,7 +228,7 @@ func createComment(e *xorm.Session, opts *CreateCommentOptions) (_ *Comment, err
 				if IsErrAttachmentNotExist(err) {
 					continue
 				}
-				return nil, fmt.Errorf("getAttachmentByUUID [%s]: %v", uuid, err)
+				return nil, errors.Newf("getAttachmentByUUID [%s]: %v", uuid, err)
 			}
 			attachments = append(attachments, attach)
 		}
@@ -237,7 +238,7 @@ func createComment(e *xorm.Session, opts *CreateCommentOptions) (_ *Comment, err
 			attachments[i].CommentID = comment.ID
 			// No assign value could be 0, so ignore AllCols().
 			if _, err = e.ID(attachments[i].ID).Update(attachments[i]); err != nil {
-				return nil, fmt.Errorf("update attachment [%d]: %v", attachments[i].ID, err)
+				return nil, errors.Newf("update attachment [%d]: %v", attachments[i].ID, err)
 			}
 		}
 
@@ -273,7 +274,7 @@ func createComment(e *xorm.Session, opts *CreateCommentOptions) (_ *Comment, err
 	}
 
 	if _, err = e.Exec("UPDATE `issue` SET updated_unix = ? WHERE id = ?", time.Now().Unix(), opts.Issue.ID); err != nil {
-		return nil, fmt.Errorf("update issue 'updated_unix': %v", err)
+		return nil, errors.Newf("update issue 'updated_unix': %v", err)
 	}
 
 	// Notify watchers for whatever action comes in, ignore if no action type.
@@ -342,7 +343,7 @@ func CreateIssueComment(doer *User, repo *Repository, issue *Issue, content stri
 		Attachments: attachments,
 	})
 	if err != nil {
-		return nil, fmt.Errorf("CreateComment: %v", err)
+		return nil, errors.Newf("CreateComment: %v", err)
 	}
 
 	comment.Issue = issue
@@ -362,7 +363,7 @@ func CreateIssueComment(doer *User, repo *Repository, issue *Issue, content stri
 // CreateRefComment creates a commit reference comment to issue.
 func CreateRefComment(doer *User, repo *Repository, issue *Issue, content, commitSHA string) error {
 	if commitSHA == "" {
-		return fmt.Errorf("cannot create reference with empty commit SHA")
+		return errors.Newf("cannot create reference with empty commit SHA")
 	}
 
 	// Check if same reference from same commit has already existed.
@@ -372,7 +373,7 @@ func CreateRefComment(doer *User, repo *Repository, issue *Issue, content, commi
 		CommitSHA: commitSHA,
 	})
 	if err != nil {
-		return fmt.Errorf("check reference comment: %v", err)
+		return errors.Newf("check reference comment: %v", err)
 	} else if has {
 		return nil
 	}
@@ -423,7 +424,7 @@ func GetCommentByID(id int64) (*Comment, error) {
 func loadCommentsAttributes(e Engine, comments []*Comment) (err error) {
 	for i := range comments {
 		if err = comments[i].loadAttributes(e); err != nil {
-			return fmt.Errorf("loadAttributes [%d]: %v", comments[i].ID, err)
+			return errors.Newf("loadAttributes [%d]: %v", comments[i].ID, err)
 		}
 	}
 
@@ -527,7 +528,7 @@ func DeleteCommentByID(doer *User, id int64) error {
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	_, err = DeleteAttachmentsByComment(comment.ID, true)

internal/database/database.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 	"gorm.io/gorm/schema"

internal/database/issue.go

@@ -2,11 +2,11 @@ package database
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/unknwon/com"
 	log "unknwon.dev/clog/v2"
 	"xorm.io/xorm"
@@ -95,7 +95,7 @@ func (issue *Issue) loadAttributes(e Engine) (err error) {
 	if issue.Repo == nil {
 		issue.Repo, err = getRepositoryByID(e, issue.RepoID)
 		if err != nil {
-			return fmt.Errorf("getRepositoryByID [%d]: %v", issue.RepoID, err)
+			return errors.Newf("getRepositoryByID [%d]: %v", issue.RepoID, err)
 		}
 	}
 
@@ -106,7 +106,7 @@ func (issue *Issue) loadAttributes(e Engine) (err error) {
 				issue.PosterID = -1
 				issue.Poster = NewGhostUser()
 			} else {
-				return fmt.Errorf("getUserByID.(Poster) [%d]: %v", issue.PosterID, err)
+				return errors.Newf("getUserByID.(Poster) [%d]: %v", issue.PosterID, err)
 			}
 		}
 	}
@@ -114,21 +114,21 @@ func (issue *Issue) loadAttributes(e Engine) (err error) {
 	if issue.Labels == nil {
 		issue.Labels, err = getLabelsByIssueID(e, issue.ID)
 		if err != nil {
-			return fmt.Errorf("getLabelsByIssueID [%d]: %v", issue.ID, err)
+			return errors.Newf("getLabelsByIssueID [%d]: %v", issue.ID, err)
 		}
 	}
 
 	if issue.Milestone == nil && issue.MilestoneID > 0 {
 		issue.Milestone, err = getMilestoneByRepoID(e, issue.RepoID, issue.MilestoneID)
 		if err != nil {
-			return fmt.Errorf("getMilestoneByRepoID [repo_id: %d, milestone_id: %d]: %v", issue.RepoID, issue.MilestoneID, err)
+			return errors.Newf("getMilestoneByRepoID [repo_id: %d, milestone_id: %d]: %v", issue.RepoID, issue.MilestoneID, err)
 		}
 	}
 
 	if issue.Assignee == nil && issue.AssigneeID > 0 {
 		issue.Assignee, err = getUserByID(e, issue.AssigneeID)
 		if err != nil {
-			return fmt.Errorf("getUserByID.(assignee) [%d]: %v", issue.AssigneeID, err)
+			return errors.Newf("getUserByID.(assignee) [%d]: %v", issue.AssigneeID, err)
 		}
 	}
 
@@ -136,21 +136,21 @@ func (issue *Issue) loadAttributes(e Engine) (err error) {
 		// It is possible pull request is not yet created.
 		issue.PullRequest, err = getPullRequestByIssueID(e, issue.ID)
 		if err != nil && !IsErrPullRequestNotExist(err) {
-			return fmt.Errorf("getPullRequestByIssueID [%d]: %v", issue.ID, err)
+			return errors.Newf("getPullRequestByIssueID [%d]: %v", issue.ID, err)
 		}
 	}
 
 	if issue.Attachments == nil {
 		issue.Attachments, err = getAttachmentsByIssueID(e, issue.ID)
 		if err != nil {
-			return fmt.Errorf("getAttachmentsByIssueID [%d]: %v", issue.ID, err)
+			return errors.Newf("getAttachmentsByIssueID [%d]: %v", issue.ID, err)
 		}
 	}
 
 	if issue.Comments == nil {
 		issue.Comments, err = getCommentsByIssueID(e, issue.ID)
 		if err != nil {
-			return fmt.Errorf("getCommentsByIssueID [%d]: %v", issue.ID, err)
+			return errors.Newf("getCommentsByIssueID [%d]: %v", issue.ID, err)
 		}
 	}
 
@@ -302,7 +302,7 @@ func (issue *Issue) getLabels(e Engine) (err error) {
 
 	issue.Labels, err = getLabelsByIssueID(e, issue.ID)
 	if err != nil {
-		return fmt.Errorf("getLabelsByIssueID: %v", err)
+		return errors.Newf("getLabelsByIssueID: %v", err)
 	}
 	return nil
 }
@@ -323,7 +323,7 @@ func (issue *Issue) RemoveLabel(doer *User, label *Label) error {
 
 func (issue *Issue) clearLabels(e *xorm.Session) (err error) {
 	if err = issue.getLabels(e); err != nil {
-		return fmt.Errorf("getLabels: %v", err)
+		return errors.Newf("getLabels: %v", err)
 	}
 
 	// NOTE: issue.removeLabel slices issue.Labels, so we need to create another slice to be unaffected.
@@ -331,7 +331,7 @@ func (issue *Issue) clearLabels(e *xorm.Session) (err error) {
 	copy(labels, issue.Labels)
 	for i := range labels {
 		if err = issue.removeLabel(e, labels[i]); err != nil {
-			return fmt.Errorf("removeLabel: %v", err)
+			return errors.Newf("removeLabel: %v", err)
 		}
 	}
 
@@ -350,7 +350,7 @@ func (issue *Issue) ClearLabels(doer *User) (err error) {
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	if issue.IsPull {
@@ -391,9 +391,9 @@ func (issue *Issue) ReplaceLabels(labels []*Label) (err error) {
 	}
 
 	if err = issue.clearLabels(sess); err != nil {
-		return fmt.Errorf("clearLabels: %v", err)
+		return errors.Newf("clearLabels: %v", err)
 	} else if err = issue.addLabels(sess, labels); err != nil {
-		return fmt.Errorf("addLabels: %v", err)
+		return errors.Newf("addLabels: %v", err)
 	}
 
 	return sess.Commit()
@@ -481,7 +481,7 @@ func (issue *Issue) ChangeStatus(doer *User, repo *Repository, isClosed bool) (e
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	if issue.IsPull {
@@ -524,7 +524,7 @@ func (issue *Issue) ChangeTitle(doer *User, title string) (err error) {
 	oldTitle := issue.Title
 	issue.Title = title
 	if err = UpdateIssueCols(issue, "name"); err != nil {
-		return fmt.Errorf("UpdateIssueCols: %v", err)
+		return errors.Newf("UpdateIssueCols: %v", err)
 	}
 
 	if issue.IsPull {
@@ -566,7 +566,7 @@ func (issue *Issue) ChangeContent(doer *User, content string) (err error) {
 	oldContent := issue.Content
 	issue.Content = content
 	if err = UpdateIssueCols(issue, "content"); err != nil {
-		return fmt.Errorf("UpdateIssueCols: %v", err)
+		return errors.Newf("UpdateIssueCols: %v", err)
 	}
 
 	if issue.IsPull {
@@ -607,7 +607,7 @@ func (issue *Issue) ChangeContent(doer *User, content string) (err error) {
 func (issue *Issue) ChangeAssignee(doer *User, assigneeID int64) (err error) {
 	issue.AssigneeID = assigneeID
 	if err = UpdateIssueUserByAssignee(issue); err != nil {
-		return fmt.Errorf("UpdateIssueUserByAssignee: %v", err)
+		return errors.Newf("UpdateIssueUserByAssignee: %v", err)
 	}
 
 	issue.Assignee, err = Handle.Users().GetByID(context.TODO(), issue.AssigneeID)
@@ -668,7 +668,7 @@ func newIssue(e *xorm.Session, opts NewIssueOptions) (err error) {
 	if opts.Issue.MilestoneID > 0 {
 		milestone, err := getMilestoneByRepoID(e, opts.Issue.RepoID, opts.Issue.MilestoneID)
 		if err != nil && !IsErrMilestoneNotExist(err) {
-			return fmt.Errorf("getMilestoneByID: %v", err)
+			return errors.Newf("getMilestoneByID: %v", err)
 		}
 
 		// Assume milestone is invalid and drop silently.
@@ -685,7 +685,7 @@ func newIssue(e *xorm.Session, opts NewIssueOptions) (err error) {
 	if opts.Issue.AssigneeID > 0 {
 		assignee, err := getUserByID(e, opts.Issue.AssigneeID)
 		if err != nil && !IsErrUserNotExist(err) {
-			return fmt.Errorf("get user by ID: %v", err)
+			return errors.Newf("get user by ID: %v", err)
 		}
 
 		if assignee != nil {
@@ -716,7 +716,7 @@ func newIssue(e *xorm.Session, opts NewIssueOptions) (err error) {
 		// So we have to get all needed labels first.
 		labels := make([]*Label, 0, len(opts.LableIDs))
 		if err = e.In("id", opts.LableIDs).Find(&labels); err != nil {
-			return fmt.Errorf("find all labels [label_ids: %v]: %v", opts.LableIDs, err)
+			return errors.Newf("find all labels [label_ids: %v]: %v", opts.LableIDs, err)
 		}
 
 		for _, label := range labels {
@@ -726,7 +726,7 @@ func newIssue(e *xorm.Session, opts NewIssueOptions) (err error) {
 			}
 
 			if err = opts.Issue.addLabel(e, label); err != nil {
-				return fmt.Errorf("addLabel [id: %d]: %v", label.ID, err)
+				return errors.Newf("addLabel [id: %d]: %v", label.ID, err)
 			}
 		}
 	}
@@ -738,13 +738,13 @@ func newIssue(e *xorm.Session, opts NewIssueOptions) (err error) {
 	if len(opts.Attachments) > 0 {
 		attachments, err := getAttachmentsByUUIDs(e, opts.Attachments)
 		if err != nil {
-			return fmt.Errorf("getAttachmentsByUUIDs [uuids: %v]: %v", opts.Attachments, err)
+			return errors.Newf("getAttachmentsByUUIDs [uuids: %v]: %v", opts.Attachments, err)
 		}
 
 		for i := 0; i < len(attachments); i++ {
 			attachments[i].IssueID = opts.Issue.ID
 			if _, err = e.ID(attachments[i].ID).Update(attachments[i]); err != nil {
-				return fmt.Errorf("update attachment [id: %d]: %v", attachments[i].ID, err)
+				return errors.Newf("update attachment [id: %d]: %v", attachments[i].ID, err)
 			}
 		}
 	}
@@ -766,11 +766,11 @@ func NewIssue(repo *Repository, issue *Issue, labelIDs []int64, uuids []string)
 		LableIDs:    labelIDs,
 		Attachments: uuids,
 	}); err != nil {
-		return fmt.Errorf("new issue: %v", err)
+		return errors.Newf("new issue: %v", err)
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	if err = NotifyWatchers(&Action{
@@ -997,13 +997,13 @@ func Issues(opts *IssuesOptions) ([]*Issue, error) {
 
 	issues := make([]*Issue, 0, conf.UI.IssuePagingNum)
 	if err := sess.Find(&issues); err != nil {
-		return nil, fmt.Errorf("find: %v", err)
+		return nil, errors.Newf("find: %v", err)
 	}
 
 	// FIXME: use IssueList to improve performance.
 	for i := range issues {
 		if err := issues[i].LoadAttributes(); err != nil {
-			return nil, fmt.Errorf("LoadAttributes [%d]: %v", issues[i].ID, err)
+			return nil, errors.Newf("LoadAttributes [%d]: %v", issues[i].ID, err)
 		}
 	}
 
@@ -1017,7 +1017,7 @@ func GetParticipantsByIssueID(issueID int64) ([]*User, error) {
 		Where("issue_id = ?", issueID).
 		Distinct("poster_id").
 		Find(&userIDs); err != nil {
-		return nil, fmt.Errorf("get poster IDs: %v", err)
+		return nil, errors.Newf("get poster IDs: %v", err)
 	}
 	if len(userIDs) == 0 {
 		return nil, nil
@@ -1051,7 +1051,7 @@ type IssueUser struct {
 func newIssueUsers(e *xorm.Session, repo *Repository, issue *Issue) error {
 	assignees, err := repo.getAssignees(e)
 	if err != nil {
-		return fmt.Errorf("getAssignees: %v", err)
+		return errors.Newf("getAssignees: %v", err)
 	}
 
 	// Poster can be anyone, append later if not one of assignees.
@@ -1166,7 +1166,7 @@ func updateIssueMentions(e Engine, issueID int64, mentions []string) error {
 	users := make([]*User, 0, len(mentions))
 
 	if err := e.In("lower_name", mentions).Asc("lower_name").Find(&users); err != nil {
-		return fmt.Errorf("find mentioned users: %v", err)
+		return errors.Newf("find mentioned users: %v", err)
 	}
 
 	ids := make([]int64, 0, len(mentions))
@@ -1179,7 +1179,7 @@ func updateIssueMentions(e Engine, issueID int64, mentions []string) error {
 		memberIDs := make([]int64, 0, user.NumMembers)
 		orgUsers, err := getOrgUsersByOrgID(e, user.ID, 0)
 		if err != nil {
-			return fmt.Errorf("getOrgUsersByOrgID [%d]: %v", user.ID, err)
+			return errors.Newf("getOrgUsersByOrgID [%d]: %v", user.ID, err)
 		}
 
 		for _, orgUser := range orgUsers {
@@ -1190,7 +1190,7 @@ func updateIssueMentions(e Engine, issueID int64, mentions []string) error {
 	}
 
 	if err := updateIssueUsersByMentions(e, issueID, ids); err != nil {
-		return fmt.Errorf("UpdateIssueUsersByMentions: %v", err)
+		return errors.Newf("UpdateIssueUsersByMentions: %v", err)
 	}
 
 	return nil

internal/database/issue_label.go

@@ -8,6 +8,7 @@ import (
 
 	"xorm.io/xorm"
 
+	"github.com/cockroachdb/errors"
 	api "github.com/gogs/go-gogs-client"
 
 	"gogs.io/gogs/internal/errutil"
@@ -22,7 +23,7 @@ var labelColorPattern = lazyregexp.New("#([a-fA-F0-9]{6})")
 func GetLabelTemplateFile(name string) ([][2]string, error) {
 	data, err := getRepoInitFile("label", name)
 	if err != nil {
-		return nil, fmt.Errorf("getRepoInitFile: %v", err)
+		return nil, errors.Newf("getRepoInitFile: %v", err)
 	}
 
 	lines := strings.Split(string(data), "\n")
@@ -35,11 +36,11 @@ func GetLabelTemplateFile(name string) ([][2]string, error) {
 
 		fields := strings.SplitN(line, " ", 2)
 		if len(fields) != 2 {
-			return nil, fmt.Errorf("line is malformed: %s", line)
+			return nil, errors.Newf("line is malformed: %s", line)
 		}
 
 		if !labelColorPattern.MatchString(fields[0]) {
-			return nil, fmt.Errorf("bad HTML color code in line: %s", line)
+			return nil, errors.Newf("bad HTML color code in line: %s", line)
 		}
 
 		fields[1] = strings.TrimSpace(fields[1])
@@ -192,7 +193,7 @@ func GetLabelsByRepoID(repoID int64) ([]*Label, error) {
 func getLabelsByIssueID(e Engine, issueID int64) ([]*Label, error) {
 	issueLabels, err := getIssueLabels(e, issueID)
 	if err != nil {
-		return nil, fmt.Errorf("getIssueLabels: %v", err)
+		return nil, errors.Newf("getIssueLabels: %v", err)
 	} else if len(issueLabels) == 0 {
 		return []*Label{}, nil
 	}
@@ -284,7 +285,7 @@ func newIssueLabel(e *xorm.Session, issue *Issue, label *Label) (err error) {
 	}
 
 	if err = updateLabel(e, label); err != nil {
-		return fmt.Errorf("updateLabel: %v", err)
+		return errors.Newf("updateLabel: %v", err)
 	}
 
 	issue.Labels = append(issue.Labels, label)
@@ -317,7 +318,7 @@ func newIssueLabels(e *xorm.Session, issue *Issue, labels []*Label) (err error)
 		}
 
 		if err = newIssueLabel(e, issue, labels[i]); err != nil {
-			return fmt.Errorf("newIssueLabel: %v", err)
+			return errors.Newf("newIssueLabel: %v", err)
 		}
 	}
 
@@ -362,7 +363,7 @@ func deleteIssueLabel(e *xorm.Session, issue *Issue, label *Label) (err error) {
 		label.NumClosedIssues--
 	}
 	if err = updateLabel(e, label); err != nil {
-		return fmt.Errorf("updateLabel: %v", err)
+		return errors.Newf("updateLabel: %v", err)
 	}
 
 	for i := range issue.Labels {

internal/database/issue_mail.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"github.com/unknwon/com"
 	log "unknwon.dev/clog/v2"
 
@@ -104,11 +104,11 @@ func mailIssueCommentToParticipants(issue *Issue, doer *User, mentions []string)
 
 	watchers, err := GetWatchers(issue.RepoID)
 	if err != nil {
-		return fmt.Errorf("GetWatchers [repo_id: %d]: %v", issue.RepoID, err)
+		return errors.Newf("GetWatchers [repo_id: %d]: %v", issue.RepoID, err)
 	}
 	participants, err := GetParticipantsByIssueID(issue.ID)
 	if err != nil {
-		return fmt.Errorf("GetParticipantsByIssueID [issue_id: %d]: %v", issue.ID, err)
+		return errors.Newf("GetParticipantsByIssueID [issue_id: %d]: %v", issue.ID, err)
 	}
 
 	// In case the issue poster is not watching the repository,
@@ -126,7 +126,7 @@ func mailIssueCommentToParticipants(issue *Issue, doer *User, mentions []string)
 
 		to, err := Handle.Users().GetByID(ctx, watchers[i].UserID)
 		if err != nil {
-			return fmt.Errorf("GetUserByID [%d]: %v", watchers[i].UserID, err)
+			return errors.Newf("GetUserByID [%d]: %v", watchers[i].UserID, err)
 		}
 		if to.IsOrganization() || !to.IsActive {
 			continue
@@ -177,7 +177,7 @@ func mailIssueCommentToParticipants(issue *Issue, doer *User, mentions []string)
 func (issue *Issue) MailParticipants() (err error) {
 	mentions := markup.FindAllMentions(issue.Content)
 	if err = updateIssueMentions(x, issue.ID, mentions); err != nil {
-		return fmt.Errorf("UpdateIssueMentions [%d]: %v", issue.ID, err)
+		return errors.Newf("UpdateIssueMentions [%d]: %v", issue.ID, err)
 	}
 
 	if err = mailIssueCommentToParticipants(issue, issue.Poster, mentions); err != nil {

internal/database/lfs.go

@@ -2,10 +2,10 @@ package database
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 
 	"gogs.io/gogs/internal/errutil"

internal/database/login_source_files.go

@@ -8,7 +8,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gopkg.in/ini.v1"
 
 	"gogs.io/gogs/internal/auth"
@@ -200,7 +200,7 @@ func loadLoginSourceFiles(authdPath string, clock func() time.Time) (loginSource
 			loginSource.Provider = github.NewProvider(&cfg)
 
 		default:
-			return fmt.Errorf("unknown type %q", authType)
+			return errors.Newf("unknown type %q", authType)
 		}
 
 		store.sources = append(store.sources, loginSource)

internal/database/login_sources.go

@@ -6,8 +6,8 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 	"gorm.io/gorm"
 
 	"gogs.io/gogs/internal/auth"
@@ -121,7 +121,7 @@ func (s *LoginSource) AfterFind(_ *gorm.DB) error {
 		s.Provider = mockProvider
 
 	default:
-		return fmt.Errorf("unrecognized login source type: %v", s.Type)
+		return errors.Newf("unrecognized login source type: %v", s.Type)
 	}
 	return nil
 }

internal/database/migrations/migrations.go

@@ -1,7 +1,7 @@
 package migrations
 
 import (
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 	log "unknwon.dev/clog/v2"
 )

internal/database/migrations/v20.go

@@ -1,7 +1,7 @@
 package migrations
 
 import (
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 
 	"gogs.io/gogs/internal/cryptoutil"

internal/database/milestone.go

@@ -7,6 +7,7 @@ import (
 	log "unknwon.dev/clog/v2"
 	"xorm.io/xorm"
 
+	"github.com/cockroachdb/errors"
 	api "github.com/gogs/go-gogs-client"
 
 	"gogs.io/gogs/internal/conf"
@@ -339,7 +340,7 @@ func ChangeMilestoneAssign(doer *User, issue *Issue, oldMilestoneID int64) (err
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	var hookAction api.HookIssueAction

internal/database/mirror.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/unknwon/com"
 	"gopkg.in/ini.v1"
 	log "unknwon.dev/clog/v2"
@@ -141,7 +142,7 @@ func (m *Mirror) SaveAddress(addr string) error {
 
 	err := git.RemoteRemove(repoPath, "origin")
 	if err != nil {
-		return fmt.Errorf("remove remote 'origin': %v", err)
+		return errors.Newf("remove remote 'origin': %v", err)
 	}
 
 	addrURL, err := url.Parse(addr)
@@ -151,7 +152,7 @@ func (m *Mirror) SaveAddress(addr string) error {
 
 	err = git.RemoteAdd(repoPath, "origin", addrURL.String(), git.RemoteAddOptions{MirrorFetch: true})
 	if err != nil {
-		return fmt.Errorf("add remote 'origin': %v", err)
+		return errors.Newf("add remote 'origin': %v", err)
 	}
 
 	return nil

internal/database/models.go

@@ -10,7 +10,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 	log "unknwon.dev/clog/v2"
@@ -97,13 +97,13 @@ func getEngine() (*xorm.Engine, error) {
 
 	case "sqlite3":
 		if err := os.MkdirAll(path.Dir(conf.Database.Path), os.ModePerm); err != nil {
-			return nil, fmt.Errorf("create directories: %v", err)
+			return nil, errors.Newf("create directories: %v", err)
 		}
 		conf.UseSQLite3 = true
 		connStr = "file:" + conf.Database.Path + "?cache=shared&mode=rwc"
 
 	default:
-		return nil, fmt.Errorf("unknown database type: %s", conf.Database.Type)
+		return nil, errors.Newf("unknown database type: %s", conf.Database.Type)
 	}
 	return xorm.NewEngine(driver, connStr)
 }
@@ -111,7 +111,7 @@ func getEngine() (*xorm.Engine, error) {
 func NewTestEngine() error {
 	x, err := getEngine()
 	if err != nil {
-		return fmt.Errorf("connect to database: %v", err)
+		return errors.Newf("connect to database: %v", err)
 	}
 
 	if conf.UsePostgreSQL {
@@ -126,7 +126,7 @@ func SetEngine() (*gorm.DB, error) {
 	var err error
 	x, err = getEngine()
 	if err != nil {
-		return nil, fmt.Errorf("connect to database: %v", err)
+		return nil, errors.Newf("connect to database: %v", err)
 	}
 
 	if conf.UsePostgreSQL {
@@ -151,7 +151,7 @@ func SetEngine() (*gorm.DB, error) {
 		},
 	)
 	if err != nil {
-		return nil, fmt.Errorf("create 'xorm.log': %v", err)
+		return nil, errors.Newf("create 'xorm.log': %v", err)
 	}
 
 	x.SetMaxOpenConns(conf.Database.MaxOpenConns)
@@ -184,7 +184,7 @@ func NewEngine() error {
 	}
 
 	if err = migrations.Migrate(db); err != nil {
-		return fmt.Errorf("migrate: %v", err)
+		return errors.Newf("migrate: %v", err)
 	}
 
 	if err = x.StoreEngine("InnoDB").Sync2(legacyTables...); err != nil {

internal/database/org.go

@@ -2,11 +2,10 @@ package database
 
 import (
 	"context"
-	"errors"
-	"fmt"
 	"os"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	"xorm.io/builder"
 	"xorm.io/xorm"
 
@@ -129,7 +128,7 @@ func CreateOrganization(org, owner *User) (err error) {
 	}
 
 	if _, err = sess.Insert(org); err != nil {
-		return fmt.Errorf("insert organization: %v", err)
+		return errors.Newf("insert organization: %v", err)
 	}
 	_ = userutil.GenerateRandomAvatar(org.ID, org.Name, org.Email)
 
@@ -140,7 +139,7 @@ func CreateOrganization(org, owner *User) (err error) {
 		IsOwner:  true,
 		NumTeams: 1,
 	}); err != nil {
-		return fmt.Errorf("insert org-user relation: %v", err)
+		return errors.Newf("insert org-user relation: %v", err)
 	}
 
 	// Create default owner team.
@@ -152,7 +151,7 @@ func CreateOrganization(org, owner *User) (err error) {
 		NumMembers: 1,
 	}
 	if _, err = sess.Insert(t); err != nil {
-		return fmt.Errorf("insert owner team: %v", err)
+		return errors.Newf("insert owner team: %v", err)
 	}
 
 	if _, err = sess.Insert(&TeamUser{
@@ -160,11 +159,11 @@ func CreateOrganization(org, owner *User) (err error) {
 		OrgID:  org.ID,
 		TeamID: t.ID,
 	}); err != nil {
-		return fmt.Errorf("insert team-user relation: %v", err)
+		return errors.Newf("insert team-user relation: %v", err)
 	}
 
 	if err = os.MkdirAll(repoutil.UserPath(org.Name), os.ModePerm); err != nil {
-		return fmt.Errorf("create directory: %v", err)
+		return errors.Newf("create directory: %v", err)
 	}
 
 	return sess.Commit()
@@ -228,7 +227,7 @@ func DeleteOrganization(org *User) error {
 		&OrgUser{OrgID: org.ID},
 		&TeamUser{OrgID: org.ID},
 	); err != nil {
-		return fmt.Errorf("deleteBeans: %v", err)
+		return errors.Newf("deleteBeans: %v", err)
 	}
 	return sess.Commit()
 }
@@ -364,24 +363,24 @@ func RemoveOrgUser(orgID, userID int64) error {
 
 	has, err := x.Where("uid=?", userID).And("org_id=?", orgID).Get(ou)
 	if err != nil {
-		return fmt.Errorf("get org-user: %v", err)
+		return errors.Newf("get org-user: %v", err)
 	} else if !has {
 		return nil
 	}
 
 	user, err := Handle.Users().GetByID(context.TODO(), userID)
 	if err != nil {
-		return fmt.Errorf("GetUserByID [%d]: %v", userID, err)
+		return errors.Newf("GetUserByID [%d]: %v", userID, err)
 	}
 	org, err := Handle.Users().GetByID(context.TODO(), orgID)
 	if err != nil {
-		return fmt.Errorf("GetUserByID [%d]: %v", orgID, err)
+		return errors.Newf("GetUserByID [%d]: %v", orgID, err)
 	}
 
 	// FIXME: only need to get IDs here, not all fields of repository.
 	repos, _, err := org.GetUserRepositories(user.ID, 1, org.NumRepos)
 	if err != nil {
-		return fmt.Errorf("GetUserRepositories [%d]: %v", user.ID, err)
+		return errors.Newf("GetUserRepositories [%d]: %v", user.ID, err)
 	}
 
 	// Check if the user to delete is the last member in owner team.
@@ -461,7 +460,7 @@ func (org *User) getUserTeams(e Engine, userID int64, cols ...string) ([]*Team,
 func (org *User) GetUserTeamIDs(userID int64) ([]int64, error) {
 	teams, err := org.getUserTeams(x, userID, "team.id")
 	if err != nil {
-		return nil, fmt.Errorf("getUserTeams [%d]: %v", userID, err)
+		return nil, errors.Newf("getUserTeams [%d]: %v", userID, err)
 	}
 
 	teamIDs := make([]int64, len(teams))
@@ -482,7 +481,7 @@ func (org *User) GetUserTeams(userID int64) ([]*Team, error) {
 func (org *User) GetUserRepositories(userID int64, page, pageSize int) ([]*Repository, int64, error) {
 	teamIDs, err := org.GetUserTeamIDs(userID)
 	if err != nil {
-		return nil, 0, fmt.Errorf("GetUserTeamIDs: %v", err)
+		return nil, 0, errors.Newf("GetUserTeamIDs: %v", err)
 	}
 	if len(teamIDs) == 0 {
 		// user has no team but "IN ()" is invalid SQL
@@ -491,7 +490,7 @@ func (org *User) GetUserRepositories(userID int64, page, pageSize int) ([]*Repos
 
 	var teamRepoIDs []int64
 	if err = x.Table("team_repo").In("team_id", teamIDs).Distinct("repo_id").Find(&teamRepoIDs); err != nil {
-		return nil, 0, fmt.Errorf("get team repository IDs: %v", err)
+		return nil, 0, errors.Newf("get team repository IDs: %v", err)
 	}
 	if len(teamRepoIDs) == 0 {
 		// team has no repo but "IN ()" is invalid SQL
@@ -509,7 +508,7 @@ func (org *User) GetUserRepositories(userID int64, page, pageSize int) ([]*Repos
 		Desc("updated_unix").
 		Limit(pageSize, (page-1)*pageSize).
 		Find(&repos); err != nil {
-		return nil, 0, fmt.Errorf("get user repositories: %v", err)
+		return nil, 0, errors.Newf("get user repositories: %v", err)
 	}
 
 	repoCount, err := x.Where("owner_id = ?", org.ID).
@@ -518,7 +517,7 @@ func (org *User) GetUserRepositories(userID int64, page, pageSize int) ([]*Repos
 			builder.In("id", teamRepoIDs))).
 		Count(new(Repository))
 	if err != nil {
-		return nil, 0, fmt.Errorf("count user repositories: %v", err)
+		return nil, 0, errors.Newf("count user repositories: %v", err)
 	}
 
 	return repos, repoCount, nil
@@ -528,7 +527,7 @@ func (org *User) GetUserRepositories(userID int64, page, pageSize int) ([]*Repos
 func (org *User) GetUserMirrorRepositories(userID int64) ([]*Repository, error) {
 	teamIDs, err := org.GetUserTeamIDs(userID)
 	if err != nil {
-		return nil, fmt.Errorf("GetUserTeamIDs: %v", err)
+		return nil, errors.Newf("GetUserTeamIDs: %v", err)
 	}
 	if len(teamIDs) == 0 {
 		teamIDs = []int64{-1}
@@ -537,7 +536,7 @@ func (org *User) GetUserMirrorRepositories(userID int64) ([]*Repository, error)
 	var teamRepoIDs []int64
 	err = x.Table("team_repo").In("team_id", teamIDs).Distinct("repo_id").Find(&teamRepoIDs)
 	if err != nil {
-		return nil, fmt.Errorf("get team repository ids: %v", err)
+		return nil, errors.Newf("get team repository ids: %v", err)
 	}
 	if len(teamRepoIDs) == 0 {
 		// team has no repo but "IN ()" is invalid SQL
@@ -551,7 +550,7 @@ func (org *User) GetUserMirrorRepositories(userID int64) ([]*Repository, error)
 		And("is_mirror = ?", true). // Don't move up because it's an independent condition
 		Desc("updated_unix").
 		Find(&repos); err != nil {
-		return nil, fmt.Errorf("get user repositories: %v", err)
+		return nil, errors.Newf("get user repositories: %v", err)
 	}
 	return repos, nil
 }

internal/database/org_team.go

@@ -2,10 +2,10 @@ package database
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	"xorm.io/xorm"
 
 	"gogs.io/gogs/internal/errutil"
@@ -55,14 +55,14 @@ func (t *Team) IsMember(userID int64) bool {
 func (t *Team) getRepositories(e Engine) (err error) {
 	teamRepos := make([]*TeamRepo, 0, t.NumRepos)
 	if err = x.Where("team_id=?", t.ID).Find(&teamRepos); err != nil {
-		return fmt.Errorf("get team-repos: %v", err)
+		return errors.Newf("get team-repos: %v", err)
 	}
 
 	t.Repos = make([]*Repository, 0, len(teamRepos))
 	for i := range teamRepos {
 		repo, err := getRepositoryByID(e, teamRepos[i].RepoID)
 		if err != nil {
-			return fmt.Errorf("getRepositoryById(%d): %v", teamRepos[i].RepoID, err)
+			return errors.Newf("getRepositoryById(%d): %v", teamRepos[i].RepoID, err)
 		}
 		t.Repos = append(t.Repos, repo)
 	}
@@ -111,19 +111,19 @@ func (t *Team) addRepository(e Engine, repo *Repository) (err error) {
 
 	t.NumRepos++
 	if _, err = e.ID(t.ID).AllCols().Update(t); err != nil {
-		return fmt.Errorf("update team: %v", err)
+		return errors.Newf("update team: %v", err)
 	}
 
 	if err = repo.recalculateTeamAccesses(e, 0); err != nil {
-		return fmt.Errorf("recalculateAccesses: %v", err)
+		return errors.Newf("recalculateAccesses: %v", err)
 	}
 
 	if err = t.getMembers(e); err != nil {
-		return fmt.Errorf("getMembers: %v", err)
+		return errors.Newf("getMembers: %v", err)
 	}
 	for _, u := range t.Members {
 		if err = watchRepo(e, u.ID, repo.ID, true); err != nil {
-			return fmt.Errorf("watchRepo: %v", err)
+			return errors.Newf("watchRepo: %v", err)
 		}
 	}
 	return nil
@@ -168,7 +168,7 @@ func (t *Team) removeRepository(e Engine, repo *Repository, recalculate bool) (e
 	}
 
 	if err = t.getMembers(e); err != nil {
-		return fmt.Errorf("get team members: %v", err)
+		return errors.Newf("get team members: %v", err)
 	}
 
 	// TODO: Delete me when this method is migrated to use GORM.
@@ -387,18 +387,18 @@ func UpdateTeam(t *Team, authChanged bool) (err error) {
 	}
 
 	if _, err = sess.ID(t.ID).AllCols().Update(t); err != nil {
-		return fmt.Errorf("update: %v", err)
+		return errors.Newf("update: %v", err)
 	}
 
 	// Update access for team members if needed.
 	if authChanged {
 		if err = t.getRepositories(sess); err != nil {
-			return fmt.Errorf("getRepositories:%v", err)
+			return errors.Newf("getRepositories:%v", err)
 		}
 
 		for _, repo := range t.Repos {
 			if err = repo.recalculateTeamAccesses(sess, 0); err != nil {
-				return fmt.Errorf("recalculateTeamAccesses: %v", err)
+				return errors.Newf("recalculateTeamAccesses: %v", err)
 			}
 		}
 	}
@@ -478,13 +478,13 @@ func getTeamMembers(e Engine, teamID int64) (_ []*User, err error) {
 	teamUsers := make([]*TeamUser, 0, 10)
 	if err = e.Sql("SELECT `id`, `org_id`, `team_id`, `uid` FROM `team_user` WHERE team_id = ?", teamID).
 		Find(&teamUsers); err != nil {
-		return nil, fmt.Errorf("get team-users: %v", err)
+		return nil, errors.Newf("get team-users: %v", err)
 	}
 	members := make([]*User, 0, len(teamUsers))
 	for i := range teamUsers {
 		member := new(User)
 		if _, err = e.ID(teamUsers[i].UID).Get(member); err != nil {
-			return nil, fmt.Errorf("get user '%d': %v", teamUsers[i].UID, err)
+			return nil, errors.Newf("get user '%d': %v", teamUsers[i].UID, err)
 		}
 		members = append(members, member)
 	}

internal/database/organizations.go

@@ -3,7 +3,7 @@ package database
 import (
 	"context"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 
 	"gogs.io/gogs/internal/dbutil"

internal/database/permissions.go

@@ -3,7 +3,7 @@ package database
 import (
 	"context"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 	log "unknwon.dev/clog/v2"
 )

internal/database/public_keys.go

@@ -4,7 +4,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 
 	"gogs.io/gogs/internal/conf"

internal/database/pull.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/unknwon/com"
 	log "unknwon.dev/clog/v2"
 	"xorm.io/xorm"
@@ -86,14 +87,14 @@ func (pr *PullRequest) loadAttributes(e Engine) (err error) {
 	if pr.HeadRepo == nil {
 		pr.HeadRepo, err = getRepositoryByID(e, pr.HeadRepoID)
 		if err != nil && !IsErrRepoNotExist(err) {
-			return fmt.Errorf("get head repository by ID: %v", err)
+			return errors.Newf("get head repository by ID: %v", err)
 		}
 	}
 
 	if pr.BaseRepo == nil {
 		pr.BaseRepo, err = getRepositoryByID(e, pr.BaseRepoID)
 		if err != nil {
-			return fmt.Errorf("get base repository by ID: %v", err)
+			return errors.Newf("get base repository by ID: %v", err)
 		}
 	}
 
@@ -103,7 +104,7 @@ func (pr *PullRequest) loadAttributes(e Engine) (err error) {
 			pr.MergerID = -1
 			pr.Merger = NewGhostUser()
 		} else if err != nil {
-			return fmt.Errorf("get merger by ID: %v", err)
+			return errors.Newf("get merger by ID: %v", err)
 		}
 	}
 
@@ -205,13 +206,13 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository, mergeStyle
 	}
 
 	if err = pr.Issue.changeStatus(sess, doer, pr.Issue.Repo, true); err != nil {
-		return fmt.Errorf("Issue.changeStatus: %v", err)
+		return errors.Newf("Issue.changeStatus: %v", err)
 	}
 
 	headRepoPath := RepoPath(pr.HeadUserName, pr.HeadRepo.Name)
 	headGitRepo, err := git.Open(headRepoPath)
 	if err != nil {
-		return fmt.Errorf("open repository: %v", err)
+		return errors.Newf("open repository: %v", err)
 	}
 
 	// Create temporary directory to store temporary copy of the base repository,
@@ -230,21 +231,21 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository, mergeStyle
 	if _, stderr, err = process.ExecTimeout(5*time.Minute,
 		fmt.Sprintf("PullRequest.Merge (git clone): %s", tmpBasePath),
 		"git", "clone", "-b", pr.BaseBranch, baseGitRepo.Path(), tmpBasePath); err != nil {
-		return fmt.Errorf("git clone: %s", stderr)
+		return errors.Newf("git clone: %s", stderr)
 	}
 
 	// Add remote which points to the head repository.
 	if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 		fmt.Sprintf("PullRequest.Merge (git remote add): %s", tmpBasePath),
 		"git", "remote", "add", "head_repo", headRepoPath); err != nil {
-		return fmt.Errorf("git remote add [%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
+		return errors.Newf("git remote add [%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
 	}
 
 	// Fetch information from head repository to the temporary copy.
 	if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 		fmt.Sprintf("PullRequest.Merge (git fetch): %s", tmpBasePath),
 		"git", "fetch", "head_repo"); err != nil {
-		return fmt.Errorf("git fetch [%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
+		return errors.Newf("git fetch [%s -> %s]: %s", headRepoPath, tmpBasePath, stderr)
 	}
 
 	remoteHeadBranch := "head_repo/" + pr.HeadBranch
@@ -261,7 +262,7 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository, mergeStyle
 		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 			fmt.Sprintf("PullRequest.Merge (git merge --no-ff --no-commit): %s", tmpBasePath),
 			"git", "merge", "--no-ff", "--no-commit", remoteHeadBranch); err != nil {
-			return fmt.Errorf("git merge --no-ff --no-commit [%s]: %v - %s", tmpBasePath, err, stderr)
+			return errors.Newf("git merge --no-ff --no-commit [%s]: %v - %s", tmpBasePath, err, stderr)
 		}
 
 		// Create a merge commit for the base branch.
@@ -270,7 +271,7 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository, mergeStyle
 			"git", "commit", fmt.Sprintf("--author='%s <%s>'", doer.DisplayName(), doer.Email),
 			"-m", fmt.Sprintf("Merge branch '%s' of %s/%s into %s", pr.HeadBranch, pr.HeadUserName, pr.HeadRepo.Name, pr.BaseBranch),
 			"-m", commitDescription); err != nil {
-			return fmt.Errorf("git commit [%s]: %v - %s", tmpBasePath, err, stderr)
+			return errors.Newf("git commit [%s]: %v - %s", tmpBasePath, err, stderr)
 		}
 
 	case MergeStyleRebase: // Rebase before merging
@@ -279,7 +280,7 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository, mergeStyle
 		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 			fmt.Sprintf("PullRequest.Merge (git rebase): %s", tmpBasePath),
 			"git", "rebase", "--quiet", pr.BaseBranch, remoteHeadBranch); err != nil {
-			return fmt.Errorf("git rebase [%s on %s]: %s", remoteHeadBranch, pr.BaseBranch, stderr)
+			return errors.Newf("git rebase [%s on %s]: %s", remoteHeadBranch, pr.BaseBranch, stderr)
 		}
 
 		// Name non-branch commit state to a new temporary branch in order to save changes.
@@ -287,48 +288,48 @@ func (pr *PullRequest) Merge(doer *User, baseGitRepo *git.Repository, mergeStyle
 		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 			fmt.Sprintf("PullRequest.Merge (git checkout): %s", tmpBasePath),
 			"git", "checkout", "-b", tmpBranch); err != nil {
-			return fmt.Errorf("git checkout '%s': %s", tmpBranch, stderr)
+			return errors.Newf("git checkout '%s': %s", tmpBranch, stderr)
 		}
 
 		// Check out the base branch to be operated on.
 		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 			fmt.Sprintf("PullRequest.Merge (git checkout): %s", tmpBasePath),
 			"git", "checkout", pr.BaseBranch); err != nil {
-			return fmt.Errorf("git checkout '%s': %s", pr.BaseBranch, stderr)
+			return errors.Newf("git checkout '%s': %s", pr.BaseBranch, stderr)
 		}
 
 		// Merge changes from temporary branch to the base branch.
 		if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 			fmt.Sprintf("PullRequest.Merge (git merge): %s", tmpBasePath),
 			"git", "merge", tmpBranch); err != nil {
-			return fmt.Errorf("git merge [%s]: %v - %s", tmpBasePath, err, stderr)
+			return errors.Newf("git merge [%s]: %v - %s", tmpBasePath, err, stderr)
 		}
 
 	default:
-		return fmt.Errorf("unknown merge style: %s", mergeStyle)
+		return errors.Newf("unknown merge style: %s", mergeStyle)
 	}
 
 	// Push changes on base branch to upstream.
 	if _, stderr, err = process.ExecDir(-1, tmpBasePath,
 		fmt.Sprintf("PullRequest.Merge (git push): %s", tmpBasePath),
 		"git", "push", baseGitRepo.Path(), pr.BaseBranch); err != nil {
-		return fmt.Errorf("git push: %s", stderr)
+		return errors.Newf("git push: %s", stderr)
 	}
 
 	pr.MergedCommitID, err = headGitRepo.BranchCommitID(pr.HeadBranch)
 	if err != nil {
-		return fmt.Errorf("get head branch %q commit ID: %v", pr.HeadBranch, err)
+		return errors.Newf("get head branch %q commit ID: %v", pr.HeadBranch, err)
 	}
 
 	pr.HasMerged = true
 	pr.Merged = time.Now()
 	pr.MergerID = doer.ID
 	if _, err = sess.ID(pr.ID).AllCols().Update(pr); err != nil {
-		return fmt.Errorf("update pull request: %v", err)
+		return errors.Newf("update pull request: %v", err)
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	if err = Handle.Actions().MergePullRequest(ctx, doer, pr.Issue.Repo.Owner, pr.Issue.Repo, pr.Issue); err != nil {
@@ -398,13 +399,13 @@ func (pr *PullRequest) testPatch() (err error) {
 	if pr.BaseRepo == nil {
 		pr.BaseRepo, err = GetRepositoryByID(pr.BaseRepoID)
 		if err != nil {
-			return fmt.Errorf("GetRepositoryByID: %v", err)
+			return errors.Newf("GetRepositoryByID: %v", err)
 		}
 	}
 
 	patchPath, err := pr.BaseRepo.PatchPath(pr.Index)
 	if err != nil {
-		return fmt.Errorf("BaseRepo.PatchPath: %v", err)
+		return errors.Newf("BaseRepo.PatchPath: %v", err)
 	}
 
 	// Fast fail if patch does not exist, this assumes data is corrupted.
@@ -419,7 +420,7 @@ func (pr *PullRequest) testPatch() (err error) {
 	log.Trace("PullRequest[%d].testPatch (patchPath): %s", pr.ID, patchPath)
 
 	if err := pr.BaseRepo.UpdateLocalCopyBranch(pr.BaseBranch); err != nil {
-		return fmt.Errorf("UpdateLocalCopy [%d]: %v", pr.BaseRepoID, err)
+		return errors.Newf("UpdateLocalCopy [%d]: %v", pr.BaseRepoID, err)
 	}
 
 	args := []string{"apply", "--check"}
@@ -455,17 +456,17 @@ func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []str
 		Attachments: uuids,
 		IsPull:      true,
 	}); err != nil {
-		return fmt.Errorf("newIssue: %v", err)
+		return errors.Newf("newIssue: %v", err)
 	}
 
 	pr.Index = pull.Index
 	if err = repo.SavePatch(pr.Index, patch); err != nil {
-		return fmt.Errorf("SavePatch: %v", err)
+		return errors.Newf("SavePatch: %v", err)
 	}
 
 	pr.BaseRepo = repo
 	if err = pr.testPatch(); err != nil {
-		return fmt.Errorf("testPatch: %v", err)
+		return errors.Newf("testPatch: %v", err)
 	}
 	// No conflict appears after test means mergeable.
 	if pr.Status == PullRequestStatusChecking {
@@ -474,11 +475,11 @@ func NewPullRequest(repo *Repository, pull *Issue, labelIDs []int64, uuids []str
 
 	pr.IssueID = pull.ID
 	if _, err = sess.Insert(pr); err != nil {
-		return fmt.Errorf("insert pull repo: %v", err)
+		return errors.Newf("insert pull repo: %v", err)
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	if err = NotifyWatchers(&Action{
@@ -620,7 +621,7 @@ func (pr *PullRequest) UpdateCols(cols ...string) error {
 func (pr *PullRequest) UpdatePatch() (err error) {
 	headGitRepo, err := git.Open(pr.HeadRepo.RepoPath())
 	if err != nil {
-		return fmt.Errorf("open repository: %v", err)
+		return errors.Newf("open repository: %v", err)
 	}
 
 	// Add a temporary remote.
@@ -628,7 +629,7 @@ func (pr *PullRequest) UpdatePatch() (err error) {
 	baseRepoPath := RepoPath(pr.BaseRepo.MustOwner().Name, pr.BaseRepo.Name)
 	err = headGitRepo.RemoteAdd(tmpRemote, baseRepoPath, git.RemoteAddOptions{Fetch: true})
 	if err != nil {
-		return fmt.Errorf("add remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
+		return errors.Newf("add remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
 	}
 	defer func() {
 		if err := headGitRepo.RemoteRemove(tmpRemote); err != nil {
@@ -639,18 +640,18 @@ func (pr *PullRequest) UpdatePatch() (err error) {
 	remoteBranch := "remotes/" + tmpRemote + "/" + pr.BaseBranch
 	pr.MergeBase, err = headGitRepo.MergeBase(remoteBranch, pr.HeadBranch)
 	if err != nil {
-		return fmt.Errorf("get merge base: %v", err)
+		return errors.Newf("get merge base: %v", err)
 	} else if err = pr.Update(); err != nil {
-		return fmt.Errorf("update: %v", err)
+		return errors.Newf("update: %v", err)
 	}
 
 	patch, err := headGitRepo.DiffBinary(pr.MergeBase, pr.HeadBranch)
 	if err != nil {
-		return fmt.Errorf("get binary patch: %v", err)
+		return errors.Newf("get binary patch: %v", err)
 	}
 
 	if err = pr.BaseRepo.SavePatch(pr.Index, patch); err != nil {
-		return fmt.Errorf("save patch: %v", err)
+		return errors.Newf("save patch: %v", err)
 	}
 
 	log.Trace("PullRequest[%d].UpdatePatch: patch saved", pr.ID)
@@ -666,12 +667,12 @@ func (pr *PullRequest) PushToBaseRepo() (err error) {
 	headRepoPath := pr.HeadRepo.RepoPath()
 	headGitRepo, err := git.Open(headRepoPath)
 	if err != nil {
-		return fmt.Errorf("open repository: %v", err)
+		return errors.Newf("open repository: %v", err)
 	}
 
 	tmpRemote := fmt.Sprintf("tmp-pull-%d", pr.ID)
 	if err = headGitRepo.RemoteAdd(tmpRemote, pr.BaseRepo.RepoPath()); err != nil {
-		return fmt.Errorf("add remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
+		return errors.Newf("add remote %q [repo_id: %d]: %v", tmpRemote, pr.HeadRepoID, err)
 	}
 
 	// Make sure to remove the remote even if the push fails
@@ -686,13 +687,13 @@ func (pr *PullRequest) PushToBaseRepo() (err error) {
 	if osutil.Exist(headFile) {
 		err = os.Remove(headFile)
 		if err != nil {
-			return fmt.Errorf("remove head file [repo_id: %d]: %v", pr.BaseRepoID, err)
+			return errors.Newf("remove head file [repo_id: %d]: %v", pr.BaseRepoID, err)
 		}
 	}
 
 	err = headGitRepo.Push(tmpRemote, fmt.Sprintf("%s:%s", pr.HeadBranch, headRefspec))
 	if err != nil {
-		return fmt.Errorf("push: %v", err)
+		return errors.Newf("push: %v", err)
 	}
 
 	return nil
@@ -726,7 +727,7 @@ func (prs PullRequestList) loadAttributes(e Engine) (err error) {
 	}
 	issues := make([]*Issue, 0, len(issueIDs))
 	if err = e.Where("id > 0").In("id", issueIDs).Find(&issues); err != nil {
-		return fmt.Errorf("find issues: %v", err)
+		return errors.Newf("find issues: %v", err)
 	}
 	for i := range issues {
 		set[issues[i].ID] = issues[i]
@@ -738,7 +739,7 @@ func (prs PullRequestList) loadAttributes(e Engine) (err error) {
 	// Load attributes
 	for i := range prs {
 		if err = prs[i].loadAttributes(e); err != nil {
-			return fmt.Errorf("loadAttributes [%d]: %v", prs[i].ID, err)
+			return errors.Newf("loadAttributes [%d]: %v", prs[i].ID, err)
 		}
 	}
 

internal/database/release.go

@@ -9,6 +9,7 @@ import (
 	log "unknwon.dev/clog/v2"
 	"xorm.io/xorm"
 
+	"github.com/cockroachdb/errors"
 	"github.com/gogs/git-module"
 	api "github.com/gogs/go-gogs-client"
 
@@ -57,7 +58,7 @@ func (r *Release) loadAttributes(e Engine) (err error) {
 	if r.Repo == nil {
 		r.Repo, err = getRepositoryByID(e, r.RepoID)
 		if err != nil {
-			return fmt.Errorf("getRepositoryByID [repo_id: %d]: %v", r.RepoID, err)
+			return errors.Newf("getRepositoryByID [repo_id: %d]: %v", r.RepoID, err)
 		}
 	}
 
@@ -68,7 +69,7 @@ func (r *Release) loadAttributes(e Engine) (err error) {
 				r.PublisherID = -1
 				r.Publisher = NewGhostUser()
 			} else {
-				return fmt.Errorf("getUserByID.(Publisher) [publisher_id: %d]: %v", r.PublisherID, err)
+				return errors.Newf("getUserByID.(Publisher) [publisher_id: %d]: %v", r.PublisherID, err)
 			}
 		}
 	}
@@ -76,7 +77,7 @@ func (r *Release) loadAttributes(e Engine) (err error) {
 	if r.Attachments == nil {
 		r.Attachments, err = getAttachmentsByReleaseID(e, r.ID)
 		if err != nil {
-			return fmt.Errorf("getAttachmentsByReleaseID [%d]: %v", r.ID, err)
+			return errors.Newf("getAttachmentsByReleaseID [%d]: %v", r.ID, err)
 		}
 	}
 
@@ -118,7 +119,7 @@ func createTag(gitRepo *git.Repository, r *Release) error {
 		if !gitRepo.HasTag(r.TagName) {
 			commit, err := gitRepo.BranchCommit(r.Target)
 			if err != nil {
-				return fmt.Errorf("get branch commit: %v", err)
+				return errors.Newf("get branch commit: %v", err)
 			}
 
 			// 🚨 SECURITY: Trim any leading '-' to prevent command line argument injection.
@@ -132,13 +133,13 @@ func createTag(gitRepo *git.Repository, r *Release) error {
 		} else {
 			commit, err := gitRepo.TagCommit(r.TagName)
 			if err != nil {
-				return fmt.Errorf("get tag commit: %v", err)
+				return errors.Newf("get tag commit: %v", err)
 			}
 
 			r.Sha1 = commit.ID.String()
 			r.NumCommits, err = commit.CommitsCount()
 			if err != nil {
-				return fmt.Errorf("count commits: %v", err)
+				return errors.Newf("count commits: %v", err)
 			}
 		}
 	}
@@ -177,17 +178,17 @@ func NewRelease(gitRepo *git.Repository, r *Release, uuids []string) error {
 	}
 
 	if _, err = sess.Insert(r); err != nil {
-		return fmt.Errorf("insert: %v", err)
+		return errors.Newf("insert: %v", err)
 	}
 
 	if len(uuids) > 0 {
 		if _, err = sess.In("uuid", uuids).Cols("release_id").Update(&Attachment{ReleaseID: r.ID}); err != nil {
-			return fmt.Errorf("link attachments: %v", err)
+			return errors.Newf("link attachments: %v", err)
 		}
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	// Only send webhook when actually published, skip drafts
@@ -196,7 +197,7 @@ func NewRelease(gitRepo *git.Repository, r *Release, uuids []string) error {
 	}
 	r, err = GetReleaseByID(r.ID)
 	if err != nil {
-		return fmt.Errorf("GetReleaseByID: %v", err)
+		return errors.Newf("GetReleaseByID: %v", err)
 	}
 	r.preparePublishWebhooks()
 	return nil
@@ -232,7 +233,7 @@ func GetRelease(repoID int64, tagName string) (*Release, error) {
 
 	r := &Release{RepoID: repoID, LowerTagName: strings.ToLower(tagName)}
 	if _, err = x.Get(r); err != nil {
-		return nil, fmt.Errorf("get: %v", err)
+		return nil, errors.Newf("get: %v", err)
 	}
 
 	return r, r.LoadAttributes()
@@ -304,7 +305,7 @@ func SortReleases(rels []*Release) {
 // UpdateRelease updates information of a release.
 func UpdateRelease(doer *User, gitRepo *git.Repository, r *Release, isPublish bool, uuids []string) (err error) {
 	if err = createTag(gitRepo, r); err != nil {
-		return fmt.Errorf("createTag: %v", err)
+		return errors.Newf("createTag: %v", err)
 	}
 
 	r.PublisherID = doer.ID
@@ -315,22 +316,22 @@ func UpdateRelease(doer *User, gitRepo *git.Repository, r *Release, isPublish bo
 		return err
 	}
 	if _, err = sess.ID(r.ID).AllCols().Update(r); err != nil {
-		return fmt.Errorf("Update: %v", err)
+		return errors.Newf("Update: %v", err)
 	}
 
 	// Unlink all current attachments and link back later if still valid
 	if _, err = sess.Exec("UPDATE attachment SET release_id = 0 WHERE release_id = ?", r.ID); err != nil {
-		return fmt.Errorf("unlink current attachments: %v", err)
+		return errors.Newf("unlink current attachments: %v", err)
 	}
 
 	if len(uuids) > 0 {
 		if _, err = sess.In("uuid", uuids).Cols("release_id").Update(&Attachment{ReleaseID: r.ID}); err != nil {
-			return fmt.Errorf("link attachments: %v", err)
+			return errors.Newf("link attachments: %v", err)
 		}
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	if !isPublish {
@@ -345,7 +346,7 @@ func UpdateRelease(doer *User, gitRepo *git.Repository, r *Release, isPublish bo
 func DeleteReleaseOfRepoByID(repoID, id int64) error {
 	rel, err := GetReleaseByID(id)
 	if err != nil {
-		return fmt.Errorf("GetReleaseByID: %v", err)
+		return errors.Newf("GetReleaseByID: %v", err)
 	}
 
 	// Mark sure the delete operation against same repository.
@@ -355,18 +356,18 @@ func DeleteReleaseOfRepoByID(repoID, id int64) error {
 
 	repo, err := GetRepositoryByID(rel.RepoID)
 	if err != nil {
-		return fmt.Errorf("GetRepositoryByID: %v", err)
+		return errors.Newf("GetRepositoryByID: %v", err)
 	}
 
 	_, stderr, err := process.ExecDir(-1, repo.RepoPath(),
 		fmt.Sprintf("DeleteReleaseByID (git tag -d): %d", rel.ID),
 		"git", "tag", "-d", rel.TagName)
 	if err != nil && !strings.Contains(stderr, "not found") {
-		return fmt.Errorf("git tag -d: %v - %s", err, stderr)
+		return errors.Newf("git tag -d: %v - %s", err, stderr)
 	}
 
 	if _, err = x.Id(rel.ID).Delete(new(Release)); err != nil {
-		return fmt.Errorf("delete: %v", err)
+		return errors.Newf("delete: %v", err)
 	}
 
 	return nil

internal/database/repo.go

@@ -15,8 +15,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/nfnt/resize"
-	"github.com/pkg/errors"
 	"github.com/unknwon/cae/zip"
 	"github.com/unknwon/com"
 	"gopkg.in/ini.v1"
@@ -256,7 +256,7 @@ func (r *Repository) loadAttributes(e Engine) (err error) {
 	if r.Owner == nil {
 		r.Owner, err = getUserByID(e, r.OwnerID)
 		if err != nil {
-			return fmt.Errorf("getUserByID [%d]: %v", r.OwnerID, err)
+			return errors.Newf("getUserByID [%d]: %v", r.OwnerID, err)
 		}
 	}
 
@@ -267,7 +267,7 @@ func (r *Repository) loadAttributes(e Engine) (err error) {
 				r.IsFork = false
 				r.ForkID = 0
 			} else {
-				return fmt.Errorf("get fork repository by ID: %v", err)
+				return errors.Newf("get fork repository by ID: %v", err)
 			}
 		}
 	}
@@ -337,19 +337,19 @@ func (r *Repository) AvatarLink() string {
 func (r *Repository) UploadAvatar(data []byte) error {
 	img, _, err := image.Decode(bytes.NewReader(data))
 	if err != nil {
-		return fmt.Errorf("decode image: %v", err)
+		return errors.Newf("decode image: %v", err)
 	}
 
 	_ = os.MkdirAll(conf.Picture.RepositoryAvatarUploadPath, os.ModePerm)
 	fw, err := os.Create(r.CustomAvatarPath())
 	if err != nil {
-		return fmt.Errorf("create custom avatar directory: %v", err)
+		return errors.Newf("create custom avatar directory: %v", err)
 	}
 	defer fw.Close()
 
 	m := resize.Resize(avatar.DefaultSize, avatar.DefaultSize, img, resize.NearestNeighbor)
 	if err = png.Encode(fw, m); err != nil {
-		return fmt.Errorf("encode image: %v", err)
+		return errors.Newf("encode image: %v", err)
 	}
 
 	return nil
@@ -446,12 +446,12 @@ func (r *Repository) mustOwner(e Engine) *User {
 func (r *Repository) UpdateSize() error {
 	countObject, err := git.CountObjects(r.RepoPath())
 	if err != nil {
-		return fmt.Errorf("count repository objects: %v", err)
+		return errors.Newf("count repository objects: %v", err)
 	}
 
 	r.Size = countObject.Size + countObject.SizePack
 	if _, err = x.Id(r.ID).Cols("size").Update(r); err != nil {
-		return fmt.Errorf("update size: %v", err)
+		return errors.Newf("update size: %v", err)
 	}
 	return nil
 }
@@ -664,24 +664,24 @@ func UpdateLocalCopyBranch(repoPath, localPath, branch string, isWiki bool) (err
 			Branch:  branch,
 			Timeout: time.Duration(conf.Git.Timeout.Clone) * time.Second,
 		}); err != nil {
-			return fmt.Errorf("git clone [branch: %s]: %v", branch, err)
+			return errors.Newf("git clone [branch: %s]: %v", branch, err)
 		}
 		return nil
 	}
 
 	gitRepo, err := git.Open(localPath)
 	if err != nil {
-		return fmt.Errorf("open repository: %v", err)
+		return errors.Newf("open repository: %v", err)
 	}
 
 	if err = gitRepo.Fetch(git.FetchOptions{
 		Prune: true,
 	}); err != nil {
-		return fmt.Errorf("fetch: %v", err)
+		return errors.Newf("fetch: %v", err)
 	}
 
 	if err = gitRepo.Checkout(branch); err != nil {
-		return fmt.Errorf("checkout [branch: %s]: %v", branch, err)
+		return errors.Newf("checkout [branch: %s]: %v", branch, err)
 	}
 
 	// Reset to align with remote in case of force push.
@@ -689,7 +689,7 @@ func UpdateLocalCopyBranch(repoPath, localPath, branch string, isWiki bool) (err
 	if err = gitRepo.Reset(rev, git.ResetOptions{
 		Hard: true,
 	}); err != nil {
-		return fmt.Errorf("reset [revision: %s]: %v", rev, err)
+		return errors.Newf("reset [revision: %s]: %v", rev, err)
 	}
 	return nil
 }
@@ -712,14 +712,14 @@ func (r *Repository) PatchPath(index int64) (string, error) {
 func (r *Repository) SavePatch(index int64, patch []byte) error {
 	patchPath, err := r.PatchPath(index)
 	if err != nil {
-		return fmt.Errorf("PatchPath: %v", err)
+		return errors.Newf("PatchPath: %v", err)
 	}
 
 	if err = os.MkdirAll(filepath.Dir(patchPath), os.ModePerm); err != nil {
 		return err
 	}
 	if err = os.WriteFile(patchPath, patch, 0o644); err != nil {
-		return fmt.Errorf("WriteFile: %v", err)
+		return errors.Newf("WriteFile: %v", err)
 	}
 
 	return nil
@@ -825,7 +825,7 @@ func MigrateRepository(doer, owner *User, opts MigrateRepoOptions) (*Repository,
 		Quiet:   true,
 		Timeout: migrateTimeout,
 	}); err != nil {
-		return repo, fmt.Errorf("clone: %v", err)
+		return repo, errors.Newf("clone: %v", err)
 	}
 
 	wikiRemotePath := wikiRemoteURL(opts.RemoteAddr)
@@ -847,7 +847,7 @@ func MigrateRepository(doer, owner *User, opts MigrateRepoOptions) (*Repository,
 		if strings.Contains(stderr, "fatal: bad default revision 'HEAD'") {
 			repo.IsBare = true
 		} else {
-			return repo, fmt.Errorf("check bare: %v - %s", err, stderr)
+			return repo, errors.Newf("check bare: %v - %s", err, stderr)
 		}
 	}
 
@@ -855,11 +855,11 @@ func MigrateRepository(doer, owner *User, opts MigrateRepoOptions) (*Repository,
 		// Try to get HEAD branch and set it as default branch.
 		gitRepo, err := git.Open(repoPath)
 		if err != nil {
-			return repo, fmt.Errorf("open repository: %v", err)
+			return repo, errors.Newf("open repository: %v", err)
 		}
 		refspec, err := gitRepo.SymbolicRef()
 		if err != nil {
-			return repo, fmt.Errorf("get HEAD branch: %v", err)
+			return repo, errors.Newf("get HEAD branch: %v", err)
 		}
 		repo.DefaultBranch = git.RefShortName(refspec)
 
@@ -875,7 +875,7 @@ func MigrateRepository(doer, owner *User, opts MigrateRepoOptions) (*Repository,
 			EnablePrune: true,
 			NextSync:    time.Now().Add(time.Duration(conf.Mirror.DefaultInterval) * time.Hour),
 		}); err != nil {
-			return repo, fmt.Errorf("InsertOne: %v", err)
+			return repo, errors.Newf("InsertOne: %v", err)
 		}
 
 		repo.IsMirror = true
@@ -890,11 +890,11 @@ func MigrateRepository(doer, owner *User, opts MigrateRepoOptions) (*Repository,
 func cleanUpMigrateGitConfig(configPath string) error {
 	cfg, err := ini.Load(configPath)
 	if err != nil {
-		return fmt.Errorf("open config file: %v", err)
+		return errors.Newf("open config file: %v", err)
 	}
 	cfg.DeleteSection("remote \"origin\"")
 	if err = cfg.SaveToIndent(configPath, "\t"); err != nil {
-		return fmt.Errorf("save config file: %v", err)
+		return errors.Newf("save config file: %v", err)
 	}
 	return nil
 }
@@ -911,7 +911,7 @@ func createDelegateHooks(repoPath string) (err error) {
 		if err = os.WriteFile(hookPath,
 			[]byte(fmt.Sprintf(hooksTpls[name], conf.Repository.ScriptType, conf.AppPath(), conf.CustomConf)),
 			os.ModePerm); err != nil {
-			return fmt.Errorf("create delegate hook '%s': %v", hookPath, err)
+			return errors.Newf("create delegate hook '%s': %v", hookPath, err)
 		}
 	}
 	return nil
@@ -921,20 +921,20 @@ func createDelegateHooks(repoPath string) (err error) {
 func CleanUpMigrateInfo(repo *Repository) (*Repository, error) {
 	repoPath := repo.RepoPath()
 	if err := createDelegateHooks(repoPath); err != nil {
-		return repo, fmt.Errorf("createDelegateHooks: %v", err)
+		return repo, errors.Newf("createDelegateHooks: %v", err)
 	}
 	if repo.HasWiki() {
 		if err := createDelegateHooks(repo.WikiPath()); err != nil {
-			return repo, fmt.Errorf("createDelegateHooks.(wiki): %v", err)
+			return repo, errors.Newf("createDelegateHooks.(wiki): %v", err)
 		}
 	}
 
 	if err := cleanUpMigrateGitConfig(repo.GitConfigPath()); err != nil {
-		return repo, fmt.Errorf("cleanUpMigrateGitConfig: %v", err)
+		return repo, errors.Newf("cleanUpMigrateGitConfig: %v", err)
 	}
 	if repo.HasWiki() {
 		if err := cleanUpMigrateGitConfig(path.Join(repo.WikiPath(), "config")); err != nil {
-			return repo, fmt.Errorf("cleanUpMigrateGitConfig.(wiki): %v", err)
+			return repo, errors.Newf("cleanUpMigrateGitConfig.(wiki): %v", err)
 		}
 	}
 
@@ -947,20 +947,20 @@ func initRepoCommit(tmpPath string, sig *git.Signature) (err error) {
 	if _, stderr, err = process.ExecDir(-1,
 		tmpPath, fmt.Sprintf("initRepoCommit (git add): %s", tmpPath),
 		"git", "add", "--all"); err != nil {
-		return fmt.Errorf("git add: %s", stderr)
+		return errors.Newf("git add: %s", stderr)
 	}
 
 	if _, stderr, err = process.ExecDir(-1,
 		tmpPath, fmt.Sprintf("initRepoCommit (git commit): %s", tmpPath),
 		"git", "commit", fmt.Sprintf("--author='%s <%s>'", sig.Name, sig.Email),
 		"-m", "Initial commit"); err != nil {
-		return fmt.Errorf("git commit: %s", stderr)
+		return errors.Newf("git commit: %s", stderr)
 	}
 
 	if _, stderr, err = process.ExecDir(-1,
 		tmpPath, fmt.Sprintf("initRepoCommit (git push): %s", tmpPath),
 		"git", "push"); err != nil {
-		return fmt.Errorf("git push: %s", stderr)
+		return errors.Newf("git push: %s", stderr)
 	}
 	return nil
 }
@@ -998,7 +998,7 @@ func prepareRepoCommit(repo *Repository, tmpDir, repoPath string, opts CreateRep
 	// README
 	data, err := getRepoInitFile("readme", opts.Readme)
 	if err != nil {
-		return fmt.Errorf("getRepoInitFile[%s]: %v", opts.Readme, err)
+		return errors.Newf("getRepoInitFile[%s]: %v", opts.Readme, err)
 	}
 
 	cloneLink := repo.CloneLink()
@@ -1010,7 +1010,7 @@ func prepareRepoCommit(repo *Repository, tmpDir, repoPath string, opts CreateRep
 	}
 	if err = os.WriteFile(filepath.Join(tmpDir, "README.md"),
 		[]byte(com.Expand(string(data), match)), 0o644); err != nil {
-		return fmt.Errorf("write README.md: %v", err)
+		return errors.Newf("write README.md: %v", err)
 	}
 
 	// .gitignore
@@ -1020,7 +1020,7 @@ func prepareRepoCommit(repo *Repository, tmpDir, repoPath string, opts CreateRep
 		for _, name := range names {
 			data, err = getRepoInitFile("gitignore", name)
 			if err != nil {
-				return fmt.Errorf("getRepoInitFile[%s]: %v", name, err)
+				return errors.Newf("getRepoInitFile[%s]: %v", name, err)
 			}
 			buf.WriteString("# ---> " + name + "\n")
 			buf.Write(data)
@@ -1029,7 +1029,7 @@ func prepareRepoCommit(repo *Repository, tmpDir, repoPath string, opts CreateRep
 
 		if buf.Len() > 0 {
 			if err = os.WriteFile(filepath.Join(tmpDir, ".gitignore"), buf.Bytes(), 0o644); err != nil {
-				return fmt.Errorf("write .gitignore: %v", err)
+				return errors.Newf("write .gitignore: %v", err)
 			}
 		}
 	}
@@ -1038,11 +1038,11 @@ func prepareRepoCommit(repo *Repository, tmpDir, repoPath string, opts CreateRep
 	if len(opts.License) > 0 {
 		data, err = getRepoInitFile("license", opts.License)
 		if err != nil {
-			return fmt.Errorf("getRepoInitFile[%s]: %v", opts.License, err)
+			return errors.Newf("getRepoInitFile[%s]: %v", opts.License, err)
 		}
 
 		if err = os.WriteFile(filepath.Join(tmpDir, "LICENSE"), data, 0o644); err != nil {
-			return fmt.Errorf("write LICENSE: %v", err)
+			return errors.Newf("write LICENSE: %v", err)
 		}
 	}
 
@@ -1053,9 +1053,9 @@ func prepareRepoCommit(repo *Repository, tmpDir, repoPath string, opts CreateRep
 func initRepository(e Engine, repoPath string, doer *User, repo *Repository, opts CreateRepoOptionsLegacy) (err error) {
 	// Init bare new repository.
 	if err = git.Init(repoPath, git.InitOptions{Bare: true}); err != nil {
-		return fmt.Errorf("init repository: %v", err)
+		return errors.Newf("init repository: %v", err)
 	} else if err = createDelegateHooks(repoPath); err != nil {
-		return fmt.Errorf("createDelegateHooks: %v", err)
+		return errors.Newf("createDelegateHooks: %v", err)
 	}
 
 	// Set default branch
@@ -1080,7 +1080,7 @@ func initRepository(e Engine, repoPath string, doer *User, repo *Repository, opt
 		defer RemoveAllWithNotice("Delete repository for auto-initialization", tmpDir)
 
 		if err = prepareRepoCommit(repo, tmpDir, repoPath, opts); err != nil {
-			return fmt.Errorf("prepareRepoCommit: %v", err)
+			return errors.Newf("prepareRepoCommit: %v", err)
 		}
 
 		// Apply changes and commit.
@@ -1093,14 +1093,14 @@ func initRepository(e Engine, repoPath string, doer *User, repo *Repository, opt
 			},
 		)
 		if err != nil {
-			return fmt.Errorf("initRepoCommit: %v", err)
+			return errors.Newf("initRepoCommit: %v", err)
 		}
 	}
 
 	// Re-fetch the repository from database before updating it (else it would
 	// override changes that were done earlier with sql)
 	if repo, err = getRepositoryByID(e, repo.ID); err != nil {
-		return fmt.Errorf("getRepositoryByID: %v", err)
+		return errors.Newf("getRepositoryByID: %v", err)
 	}
 
 	if !opts.AutoInit {
@@ -1109,7 +1109,7 @@ func initRepository(e Engine, repoPath string, doer *User, repo *Repository, opt
 
 	repo.DefaultBranch = conf.Repository.DefaultBranch
 	if err = updateRepository(e, repo, false); err != nil {
-		return fmt.Errorf("updateRepository: %v", err)
+		return errors.Newf("updateRepository: %v", err)
 	}
 
 	return nil
@@ -1138,7 +1138,7 @@ func createRepository(e *xorm.Session, doer, owner *User, repo *Repository) (err
 
 	has, err := isRepositoryExist(e, owner, repo.Name)
 	if err != nil {
-		return fmt.Errorf("IsRepositoryExist: %v", err)
+		return errors.Newf("IsRepositoryExist: %v", err)
 	} else if has {
 		return ErrRepoAlreadyExist{args: errutil.Args{"ownerID": owner.ID, "name": repo.Name}}
 	}
@@ -1156,19 +1156,19 @@ func createRepository(e *xorm.Session, doer, owner *User, repo *Repository) (err
 	if owner.IsOrganization() {
 		t, err := owner.getOwnerTeam(e)
 		if err != nil {
-			return fmt.Errorf("getOwnerTeam: %v", err)
+			return errors.Newf("getOwnerTeam: %v", err)
 		} else if err = t.addRepository(e, repo); err != nil {
-			return fmt.Errorf("addRepository: %v", err)
+			return errors.Newf("addRepository: %v", err)
 		}
 	} else {
 		// Organization automatically called this in addRepository method.
 		if err = repo.recalculateAccesses(e); err != nil {
-			return fmt.Errorf("recalculateAccesses: %v", err)
+			return errors.Newf("recalculateAccesses: %v", err)
 		}
 	}
 
 	if err = watchRepo(e, owner.ID, repo.ID, true); err != nil {
-		return fmt.Errorf("watchRepo: %v", err)
+		return errors.Newf("watchRepo: %v", err)
 	}
 
 	// FIXME: This is identical to Actions.NewRepo but we are not yet able to wrap
@@ -1192,7 +1192,7 @@ func createRepository(e *xorm.Session, doer, owner *User, repo *Repository) (err
 		})
 	}
 	if err = newRepoAction(e, doer, repo); err != nil {
-		return fmt.Errorf("newRepoAction: %v", err)
+		return errors.Newf("newRepoAction: %v", err)
 	}
 
 	return repo.loadAttributes(e)
@@ -1248,14 +1248,14 @@ func CreateRepository(doer, owner *User, opts CreateRepoOptionsLegacy) (_ *Repos
 	if !opts.IsMirror {
 		if err = initRepository(sess, repoPath, doer, repo, opts); err != nil {
 			RemoveAllWithNotice("Delete repository for initialization failure", repoPath)
-			return nil, fmt.Errorf("initRepository: %v", err)
+			return nil, errors.Newf("initRepository: %v", err)
 		}
 
 		_, stderr, err := process.ExecDir(-1,
 			repoPath, fmt.Sprintf("CreateRepository 'git update-server-info': %s", repoPath),
 			"git", "update-server-info")
 		if err != nil {
-			return nil, fmt.Errorf("CreateRepository 'git update-server-info': %s", stderr)
+			return nil, errors.Newf("CreateRepository 'git update-server-info': %s", stderr)
 		}
 	}
 	if err = sess.Commit(); err != nil {
@@ -1311,7 +1311,7 @@ func Repositories(page, pageSize int) (_ []*Repository, err error) {
 func RepositoriesWithUsers(page, pageSize int) (_ []*Repository, err error) {
 	repos, err := Repositories(page, pageSize)
 	if err != nil {
-		return nil, fmt.Errorf("Repositories: %v", err)
+		return nil, errors.Newf("Repositories: %v", err)
 	}
 
 	for i := range repos {
@@ -1337,7 +1337,7 @@ func FilterRepositoryWithIssues(repoIDs []int64) ([]int64, error) {
 		In("id", repoIDs).
 		Cols("id").
 		Find(&repos); err != nil {
-		return nil, fmt.Errorf("filter valid repositories %v: %v", repoIDs, err)
+		return nil, errors.Newf("filter valid repositories %v: %v", repoIDs, err)
 	}
 
 	if len(repos) == 0 {
@@ -1362,13 +1362,13 @@ func RepoPath(userName, repoName string) string {
 func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error {
 	newOwner, err := Handle.Users().GetByUsername(context.TODO(), newOwnerName)
 	if err != nil {
-		return fmt.Errorf("get new owner '%s': %v", newOwnerName, err)
+		return errors.Newf("get new owner '%s': %v", newOwnerName, err)
 	}
 
 	// Check if new owner has repository with same name.
 	has, err := IsRepositoryExist(newOwner, repo.Name)
 	if err != nil {
-		return fmt.Errorf("IsRepositoryExist: %v", err)
+		return errors.Newf("IsRepositoryExist: %v", err)
 	} else if has {
 		return ErrRepoAlreadyExist{args: errutil.Args{"ownerName": newOwnerName, "name": repo.Name}}
 	}
@@ -1376,7 +1376,7 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 	sess := x.NewSession()
 	defer sess.Close()
 	if err = sess.Begin(); err != nil {
-		return fmt.Errorf("sess.Begin: %v", err)
+		return errors.Newf("sess.Begin: %v", err)
 	}
 
 	owner := repo.Owner
@@ -1388,13 +1388,13 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 
 	// Update repository.
 	if _, err := sess.ID(repo.ID).Update(repo); err != nil {
-		return fmt.Errorf("update owner: %v", err)
+		return errors.Newf("update owner: %v", err)
 	}
 
 	// Remove redundant collaborators.
 	collaborators, err := repo.getCollaborators(sess)
 	if err != nil {
-		return fmt.Errorf("getCollaborators: %v", err)
+		return errors.Newf("getCollaborators: %v", err)
 	}
 
 	// Dummy object.
@@ -1403,7 +1403,7 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 		collaboration.UserID = c.ID
 		if c.ID == newOwner.ID || newOwner.IsOrgMember(c.ID) {
 			if _, err = sess.Delete(collaboration); err != nil {
-				return fmt.Errorf("remove collaborator '%d': %v", c.ID, err)
+				return errors.Newf("remove collaborator '%d': %v", c.ID, err)
 			}
 		}
 	}
@@ -1411,7 +1411,7 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 	// Remove old team-repository relations.
 	if owner.IsOrganization() {
 		if err = owner.getTeams(sess); err != nil {
-			return fmt.Errorf("getTeams: %v", err)
+			return errors.Newf("getTeams: %v", err)
 		}
 		for _, t := range owner.Teams {
 			if !t.hasRepository(sess, repo.ID) {
@@ -1420,34 +1420,34 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 
 			t.NumRepos--
 			if _, err := sess.ID(t.ID).AllCols().Update(t); err != nil {
-				return fmt.Errorf("decrease team repository count '%d': %v", t.ID, err)
+				return errors.Newf("decrease team repository count '%d': %v", t.ID, err)
 			}
 		}
 
 		if err = owner.removeOrgRepo(sess, repo.ID); err != nil {
-			return fmt.Errorf("removeOrgRepo: %v", err)
+			return errors.Newf("removeOrgRepo: %v", err)
 		}
 	}
 
 	if newOwner.IsOrganization() {
 		t, err := newOwner.getOwnerTeam(sess)
 		if err != nil {
-			return fmt.Errorf("getOwnerTeam: %v", err)
+			return errors.Newf("getOwnerTeam: %v", err)
 		} else if err = t.addRepository(sess, repo); err != nil {
-			return fmt.Errorf("add to owner team: %v", err)
+			return errors.Newf("add to owner team: %v", err)
 		}
 	} else {
 		// Organization called this in addRepository method.
 		if err = repo.recalculateAccesses(sess); err != nil {
-			return fmt.Errorf("recalculateAccesses: %v", err)
+			return errors.Newf("recalculateAccesses: %v", err)
 		}
 	}
 
 	// Update repository count.
 	if _, err = sess.Exec("UPDATE `user` SET num_repos=num_repos+1 WHERE id=?", newOwner.ID); err != nil {
-		return fmt.Errorf("increase new owner repository count: %v", err)
+		return errors.Newf("increase new owner repository count: %v", err)
 	} else if _, err = sess.Exec("UPDATE `user` SET num_repos=num_repos-1 WHERE id=?", owner.ID); err != nil {
-		return fmt.Errorf("decrease old owner repository count: %v", err)
+		return errors.Newf("decrease old owner repository count: %v", err)
 	}
 
 	// Remove watch for organization.
@@ -1458,7 +1458,7 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 	}
 
 	if err = watchRepo(sess, newOwner.ID, repo.ID, true); err != nil {
-		return fmt.Errorf("watchRepo: %v", err)
+		return errors.Newf("watchRepo: %v", err)
 	}
 
 	// FIXME: This is identical to Actions.TransferRepo but we are not yet able to
@@ -1478,7 +1478,7 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 		})
 	}
 	if err = transferRepoAction(sess, doer, owner, repo); err != nil {
-		return fmt.Errorf("transferRepoAction: %v", err)
+		return errors.Newf("transferRepoAction: %v", err)
 	}
 
 	// Rename remote repository to new path and delete local copy.
@@ -1486,7 +1486,7 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 		return err
 	}
 	if err = os.Rename(RepoPath(owner.Name, repo.Name), RepoPath(newOwner.Name, repo.Name)); err != nil {
-		return fmt.Errorf("rename repository directory: %v", err)
+		return errors.Newf("rename repository directory: %v", err)
 	}
 
 	deleteRepoLocalCopy(repo.ID)
@@ -1496,7 +1496,7 @@ func TransferOwnership(doer *User, newOwnerName string, repo *Repository) error
 	if com.IsExist(wikiPath) {
 		RemoveAllWithNotice("Delete repository wiki local copy", repo.LocalWikiPath())
 		if err = os.Rename(wikiPath, WikiPath(newOwner.Name, repo.Name)); err != nil {
-			return fmt.Errorf("rename repository wiki: %v", err)
+			return errors.Newf("rename repository wiki: %v", err)
 		}
 	}
 
@@ -1519,25 +1519,25 @@ func ChangeRepositoryName(u *User, oldRepoName, newRepoName string) (err error)
 
 	has, err := IsRepositoryExist(u, newRepoName)
 	if err != nil {
-		return fmt.Errorf("IsRepositoryExist: %v", err)
+		return errors.Newf("IsRepositoryExist: %v", err)
 	} else if has {
 		return ErrRepoAlreadyExist{args: errutil.Args{"ownerID": u.ID, "name": newRepoName}}
 	}
 
 	repo, err := GetRepositoryByName(u.ID, oldRepoName)
 	if err != nil {
-		return fmt.Errorf("GetRepositoryByName: %v", err)
+		return errors.Newf("GetRepositoryByName: %v", err)
 	}
 
 	// Change repository directory name
 	if err = os.Rename(repo.RepoPath(), RepoPath(u.Name, newRepoName)); err != nil {
-		return fmt.Errorf("rename repository directory: %v", err)
+		return errors.Newf("rename repository directory: %v", err)
 	}
 
 	wikiPath := repo.WikiPath()
 	if com.IsExist(wikiPath) {
 		if err = os.Rename(wikiPath, WikiPath(u.Name, newRepoName)); err != nil {
-			return fmt.Errorf("rename repository wiki: %v", err)
+			return errors.Newf("rename repository wiki: %v", err)
 		}
 		RemoveAllWithNotice("Delete repository wiki local copy", repo.LocalWikiPath())
 	}
@@ -1577,17 +1577,17 @@ func updateRepository(e Engine, repo *Repository, visibilityChanged bool) (err e
 	}
 
 	if _, err = e.ID(repo.ID).AllCols().Update(repo); err != nil {
-		return fmt.Errorf("update: %v", err)
+		return errors.Newf("update: %v", err)
 	}
 
 	if visibilityChanged {
 		if err = repo.getOwner(e); err != nil {
-			return fmt.Errorf("getOwner: %v", err)
+			return errors.Newf("getOwner: %v", err)
 		}
 		if repo.Owner.IsOrganization() {
 			// Organization repository need to recalculate access table when visibility is changed
 			if err = repo.recalculateTeamAccesses(e, 0); err != nil {
-				return fmt.Errorf("recalculateTeamAccesses: %v", err)
+				return errors.Newf("recalculateTeamAccesses: %v", err)
 			}
 		}
 
@@ -1607,19 +1607,19 @@ func updateRepository(e Engine, repo *Repository, visibilityChanged bool) (err e
 
 		forkRepos, err := getRepositoriesByForkID(e, repo.ID)
 		if err != nil {
-			return fmt.Errorf("getRepositoriesByForkID: %v", err)
+			return errors.Newf("getRepositoriesByForkID: %v", err)
 		}
 		for i := range forkRepos {
 			forkRepos[i].IsPrivate = repo.IsPrivate
 			forkRepos[i].IsUnlisted = repo.IsUnlisted
 			if err = updateRepository(e, forkRepos[i], true); err != nil {
-				return fmt.Errorf("updateRepository[%d]: %v", forkRepos[i].ID, err)
+				return errors.Newf("updateRepository[%d]: %v", forkRepos[i].ID, err)
 			}
 		}
 
 		// Change visibility of generated actions
 		if _, err = e.Where("repo_id = ?", repo.ID).Cols("is_private").Update(&Action{IsPrivate: repo.IsPrivate || repo.IsUnlisted}); err != nil {
-			return fmt.Errorf("change action visibility of repository: %v", err)
+			return errors.Newf("change action visibility of repository: %v", err)
 		}
 	}
 
@@ -1634,7 +1634,7 @@ func UpdateRepository(repo *Repository, visibilityChanged bool) (err error) {
 	}
 
 	if err = updateRepository(x, repo, visibilityChanged); err != nil {
-		return fmt.Errorf("updateRepository: %v", err)
+		return errors.Newf("updateRepository: %v", err)
 	}
 
 	return sess.Commit()
@@ -1695,7 +1695,7 @@ func DeleteRepository(ownerID, repoID int64) error {
 		&HookTask{RepoID: repoID},
 		&LFSObject{RepoID: repoID},
 	); err != nil {
-		return fmt.Errorf("deleteBeans: %v", err)
+		return errors.Newf("deleteBeans: %v", err)
 	}
 
 	// Delete comments and attachments.
@@ -1728,7 +1728,7 @@ func DeleteRepository(ownerID, repoID int64) error {
 
 	if repo.IsFork {
 		if _, err = sess.Exec("UPDATE `repository` SET num_forks=num_forks-1 WHERE id=?", repo.ForkID); err != nil {
-			return fmt.Errorf("decrease fork count: %v", err)
+			return errors.Newf("decrease fork count: %v", err)
 		}
 	}
 
@@ -1737,7 +1737,7 @@ func DeleteRepository(ownerID, repoID int64) error {
 	}
 
 	if err = sess.Commit(); err != nil {
-		return fmt.Errorf("commit: %v", err)
+		return errors.Newf("commit: %v", err)
 	}
 
 	// Remove repository files.
@@ -1852,12 +1852,12 @@ func GetUserAndCollaborativeRepositories(userID int64) ([]*Repository, error) {
 		Join("INNER", "collaboration", "collaboration.repo_id = repo.id").
 		Where("collaboration.user_id = ?", userID).
 		Find(&repos); err != nil {
-		return nil, fmt.Errorf("select collaborative repositories: %v", err)
+		return nil, errors.Newf("select collaborative repositories: %v", err)
 	}
 
 	ownRepos := make([]*Repository, 0, 10)
 	if err := x.Where("owner_id = ?", userID).Find(&ownRepos); err != nil {
-		return nil, fmt.Errorf("select own repositories: %v", err)
+		return nil, errors.Newf("select own repositories: %v", err)
 	}
 
 	return append(repos, ownRepos...), nil
@@ -1903,7 +1903,7 @@ func SearchRepositoryByName(opts *SearchRepoOptions) (repos []*Repository, count
 	// We need all fields (repo.*) in final list but only ID (repo.id) is good enough for counting.
 	count, err = sess.Clone().Distinct("repo.id").Count(new(Repository))
 	if err != nil {
-		return nil, 0, fmt.Errorf("Count: %v", err)
+		return nil, 0, errors.Newf("Count: %v", err)
 	}
 
 	if len(opts.OrderBy) > 0 {
@@ -1998,7 +1998,7 @@ func gatherMissingRepoRecords() ([]*Repository, error) {
 			return nil
 		}); err != nil {
 		if err2 := Handle.Notices().Create(context.TODO(), NoticeTypeRepository, fmt.Sprintf("gatherMissingRepoRecords: %v", err)); err2 != nil {
-			return nil, fmt.Errorf("CreateRepositoryNotice: %v", err)
+			return nil, errors.Newf("CreateRepositoryNotice: %v", err)
 		}
 	}
 	return repos, nil
@@ -2008,7 +2008,7 @@ func gatherMissingRepoRecords() ([]*Repository, error) {
 func DeleteMissingRepositories() error {
 	repos, err := gatherMissingRepoRecords()
 	if err != nil {
-		return fmt.Errorf("gatherMissingRepoRecords: %v", err)
+		return errors.Newf("gatherMissingRepoRecords: %v", err)
 	}
 
 	if len(repos) == 0 {
@@ -2019,7 +2019,7 @@ func DeleteMissingRepositories() error {
 		log.Trace("Deleting %d/%d...", repo.OwnerID, repo.ID)
 		if err := DeleteRepository(repo.OwnerID, repo.ID); err != nil {
 			if err2 := Handle.Notices().Create(context.TODO(), NoticeTypeRepository, fmt.Sprintf("DeleteRepository [%d]: %v", repo.ID, err)); err2 != nil {
-				return fmt.Errorf("CreateRepositoryNotice: %v", err)
+				return errors.Newf("CreateRepositoryNotice: %v", err)
 			}
 		}
 	}
@@ -2030,7 +2030,7 @@ func DeleteMissingRepositories() error {
 func ReinitMissingRepositories() error {
 	repos, err := gatherMissingRepoRecords()
 	if err != nil {
-		return fmt.Errorf("gatherMissingRepoRecords: %v", err)
+		return errors.Newf("gatherMissingRepoRecords: %v", err)
 	}
 
 	if len(repos) == 0 {
@@ -2041,7 +2041,7 @@ func ReinitMissingRepositories() error {
 		log.Trace("Initializing %d/%d...", repo.OwnerID, repo.ID)
 		if err := git.Init(repo.RepoPath(), git.InitOptions{Bare: true}); err != nil {
 			if err2 := Handle.Notices().Create(context.TODO(), NoticeTypeRepository, fmt.Sprintf("init repository [repo_id: %d]: %v", repo.ID, err)); err2 != nil {
-				return fmt.Errorf("create repository notice: %v", err)
+				return errors.Newf("create repository notice: %v", err)
 			}
 		}
 	}
@@ -2125,7 +2125,7 @@ func GitGcRepos() error {
 				RepoPath(repo.Owner.Name, repo.Name), "Repository garbage collection",
 				"git", args...)
 			if err != nil {
-				return fmt.Errorf("%v: %v", err, stderr)
+				return errors.Newf("%v: %v", err, stderr)
 			}
 			return nil
 		})
@@ -2264,7 +2264,7 @@ func (repos RepositoryList) loadAttributes(e Engine) error {
 	}
 	users := make([]*User, 0, len(userIDs))
 	if err := e.Where("id > 0").In("id", userIDs).Find(&users); err != nil {
-		return fmt.Errorf("find users: %v", err)
+		return errors.Newf("find users: %v", err)
 	}
 	for i := range users {
 		userSet[users[i].ID] = users[i]
@@ -2286,7 +2286,7 @@ func (repos RepositoryList) loadAttributes(e Engine) error {
 	}
 	baseRepos := make([]*Repository, 0, len(baseIDs))
 	if err := e.Where("id > 0").In("id", baseIDs).Find(&baseRepos); err != nil {
-		return fmt.Errorf("find base repositories: %v", err)
+		return errors.Newf("find base repositories: %v", err)
 	}
 	for i := range baseRepos {
 		repoSet[baseRepos[i].ID] = baseRepos[i]
@@ -2322,7 +2322,7 @@ func (repos MirrorRepositoryList) loadAttributes(e Engine) error {
 	}
 	mirrors := make([]*Mirror, 0, len(repoIDs))
 	if err := e.Where("id > 0").In("repo_id", repoIDs).Find(&mirrors); err != nil {
-		return fmt.Errorf("find mirrors: %v", err)
+		return errors.Newf("find mirrors: %v", err)
 	}
 
 	set := make(map[int64]*Mirror)
@@ -2425,7 +2425,7 @@ func notifyWatchers(e Engine, act *Action) error {
 	// Add feeds for user self and all watchers.
 	watchers, err := getWatchers(e, act.RepoID)
 	if err != nil {
-		return fmt.Errorf("getWatchers: %v", err)
+		return errors.Newf("getWatchers: %v", err)
 	}
 
 	// Reset ID to reuse Action object
@@ -2434,7 +2434,7 @@ func notifyWatchers(e Engine, act *Action) error {
 	// Add feed for actioner.
 	act.UserID = act.ActUserID
 	if _, err = e.Insert(act); err != nil {
-		return fmt.Errorf("insert new action: %v", err)
+		return errors.Newf("insert new action: %v", err)
 	}
 
 	for i := range watchers {
@@ -2445,7 +2445,7 @@ func notifyWatchers(e Engine, act *Action) error {
 		act.ID = 0
 		act.UserID = watchers[i].UserID
 		if _, err = e.Insert(act); err != nil {
-			return fmt.Errorf("insert new action: %v", err)
+			return errors.Newf("insert new action: %v", err)
 		}
 	}
 	return nil
@@ -2574,22 +2574,22 @@ func ForkRepository(doer, owner *User, baseRepo *Repository, name, desc string)
 		fmt.Sprintf("ForkRepository 'git clone': %s/%s", owner.Name, repo.Name),
 		"git", "clone", "--bare", baseRepo.RepoPath(), repoPath)
 	if err != nil {
-		return nil, fmt.Errorf("git clone: %v - %s", err, stderr)
+		return nil, errors.Newf("git clone: %v - %s", err, stderr)
 	}
 
 	_, stderr, err = process.ExecDir(-1,
 		repoPath, fmt.Sprintf("ForkRepository 'git update-server-info': %s", repoPath),
 		"git", "update-server-info")
 	if err != nil {
-		return nil, fmt.Errorf("git update-server-info: %v - %s", err, stderr)
+		return nil, errors.Newf("git update-server-info: %v - %s", err, stderr)
 	}
 
 	if err = createDelegateHooks(repoPath); err != nil {
-		return nil, fmt.Errorf("createDelegateHooks: %v", err)
+		return nil, errors.Newf("createDelegateHooks: %v", err)
 	}
 
 	if err = sess.Commit(); err != nil {
-		return nil, fmt.Errorf("commit: %v", err)
+		return nil, errors.Newf("commit: %v", err)
 	}
 
 	// Remember visibility preference
@@ -2638,17 +2638,17 @@ func (r *Repository) CreateNewBranch(oldBranch, newBranch string) (err error) {
 	localPath := r.LocalCopyPath()
 
 	if err = discardLocalRepoBranchChanges(localPath, oldBranch); err != nil {
-		return fmt.Errorf("discard changes in local copy [path: %s, branch: %s]: %v", localPath, oldBranch, err)
+		return errors.Newf("discard changes in local copy [path: %s, branch: %s]: %v", localPath, oldBranch, err)
 	} else if err = r.UpdateLocalCopyBranch(oldBranch); err != nil {
-		return fmt.Errorf("update branch for local copy [path: %s, branch: %s]: %v", localPath, oldBranch, err)
+		return errors.Newf("update branch for local copy [path: %s, branch: %s]: %v", localPath, oldBranch, err)
 	}
 
 	if err = r.CheckoutNewBranch(oldBranch, newBranch); err != nil {
-		return fmt.Errorf("create new branch [base: %s, new: %s]: %v", oldBranch, newBranch, err)
+		return errors.Newf("create new branch [base: %s, new: %s]: %v", oldBranch, newBranch, err)
 	}
 
 	if err = git.Push(localPath, "origin", newBranch); err != nil {
-		return fmt.Errorf("push [branch: %s]: %v", newBranch, err)
+		return errors.Newf("push [branch: %s]: %v", newBranch, err)
 	}
 
 	return nil
@@ -2667,9 +2667,9 @@ func (r *Repository) refreshAccesses(e Engine, accessMap map[int64]AccessMode) (
 
 	// Delete old accesses and insert new ones for repository.
 	if _, err = e.Delete(&Access{RepoID: r.ID}); err != nil {
-		return fmt.Errorf("delete old accesses: %v", err)
+		return errors.Newf("delete old accesses: %v", err)
 	} else if _, err = e.Insert(newAccesses); err != nil {
-		return fmt.Errorf("insert new accesses: %v", err)
+		return errors.Newf("insert new accesses: %v", err)
 	}
 	return nil
 }
@@ -2678,7 +2678,7 @@ func (r *Repository) refreshAccesses(e Engine, accessMap map[int64]AccessMode) (
 func (r *Repository) refreshCollaboratorAccesses(e Engine, accessMap map[int64]AccessMode) error {
 	collaborations, err := r.getCollaborations(e)
 	if err != nil {
-		return fmt.Errorf("getCollaborations: %v", err)
+		return errors.Newf("getCollaborations: %v", err)
 	}
 	for _, c := range collaborations {
 		accessMap[c.UserID] = c.Mode
@@ -2695,11 +2695,11 @@ func (r *Repository) recalculateTeamAccesses(e Engine, ignTeamID int64) (err err
 	if err = r.getOwner(e); err != nil {
 		return err
 	} else if !r.Owner.IsOrganization() {
-		return fmt.Errorf("owner is not an organization: %d", r.OwnerID)
+		return errors.Newf("owner is not an organization: %d", r.OwnerID)
 	}
 
 	if err = r.refreshCollaboratorAccesses(e, accessMap); err != nil {
-		return fmt.Errorf("refreshCollaboratorAccesses: %v", err)
+		return errors.Newf("refreshCollaboratorAccesses: %v", err)
 	}
 
 	if err = r.Owner.getTeams(e); err != nil {
@@ -2730,7 +2730,7 @@ func (r *Repository) recalculateTeamAccesses(e Engine, ignTeamID int64) (err err
 		}
 
 		if err = t.getMembers(e); err != nil {
-			return fmt.Errorf("getMembers '%d': %v", t.ID, err)
+			return errors.Newf("getMembers '%d': %v", t.ID, err)
 		}
 		for _, m := range t.Members {
 			accessMap[m.ID] = maxAccessMode(accessMap[m.ID], t.Authorize)
@@ -2747,7 +2747,7 @@ func (r *Repository) recalculateAccesses(e Engine) error {
 
 	accessMap := make(map[int64]AccessMode, 10)
 	if err := r.refreshCollaboratorAccesses(e, accessMap); err != nil {
-		return fmt.Errorf("refreshCollaboratorAccesses: %v", err)
+		return errors.Newf("refreshCollaboratorAccesses: %v", err)
 	}
 	return r.refreshAccesses(e, accessMap)
 }

internal/database/repo_branch.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	"github.com/gogs/git-module"
 	"github.com/unknwon/com"
 
@@ -23,12 +24,12 @@ type Branch struct {
 func GetBranchesByPath(path string) ([]*Branch, error) {
 	gitRepo, err := git.Open(path)
 	if err != nil {
-		return nil, fmt.Errorf("open repository: %v", err)
+		return nil, errors.Newf("open repository: %v", err)
 	}
 
 	names, err := gitRepo.Branches()
 	if err != nil {
-		return nil, fmt.Errorf("list branches")
+		return nil, errors.Newf("list branches")
 	}
 
 	branches := make([]*Branch, len(names))
@@ -77,7 +78,7 @@ func (r *Repository) GetBranches() ([]*Branch, error) {
 func (br *Branch) GetCommit() (*git.Commit, error) {
 	gitRepo, err := git.Open(br.RepoPath)
 	if err != nil {
-		return nil, fmt.Errorf("open repository: %v", err)
+		return nil, errors.Newf("open repository: %v", err)
 	}
 	return gitRepo.BranchCommit(br.Name)
 }
@@ -143,12 +144,12 @@ func UpdateProtectBranch(protectBranch *ProtectBranch) (err error) {
 
 	if protectBranch.ID == 0 {
 		if _, err = sess.Insert(protectBranch); err != nil {
-			return fmt.Errorf("insert: %v", err)
+			return errors.Newf("insert: %v", err)
 		}
 	}
 
 	if _, err = sess.ID(protectBranch.ID).AllCols().Update(protectBranch); err != nil {
-		return fmt.Errorf("update: %v", err)
+		return errors.Newf("update: %v", err)
 	}
 
 	return sess.Commit()
@@ -160,9 +161,9 @@ func UpdateProtectBranch(protectBranch *ProtectBranch) (err error) {
 // to avoid unnecessary whitelist delete and regenerate.
 func UpdateOrgProtectBranch(repo *Repository, protectBranch *ProtectBranch, whitelistUserIDs, whitelistTeamIDs string) (err error) {
 	if err = repo.GetOwner(); err != nil {
-		return fmt.Errorf("GetOwner: %v", err)
+		return errors.Newf("GetOwner: %v", err)
 	} else if !repo.Owner.IsOrganization() {
-		return fmt.Errorf("expect repository owner to be an organization")
+		return errors.Newf("expect repository owner to be an organization")
 	}
 
 	hasUsersChanged := false
@@ -194,7 +195,7 @@ func UpdateOrgProtectBranch(repo *Repository, protectBranch *ProtectBranch, whit
 		teamIDs := tool.StringsToInt64s(strings.Split(whitelistTeamIDs, ","))
 		teams, err := GetTeamsHaveAccessToRepo(repo.OwnerID, repo.ID, AccessModeWrite)
 		if err != nil {
-			return fmt.Errorf("GetTeamsHaveAccessToRepo [org_id: %d, repo_id: %d]: %v", repo.OwnerID, repo.ID, err)
+			return errors.Newf("GetTeamsHaveAccessToRepo [org_id: %d, repo_id: %d]: %v", repo.OwnerID, repo.ID, err)
 		}
 		validTeamIDs = make([]int64, 0, len(teams))
 		for i := range teams {
@@ -209,7 +210,7 @@ func UpdateOrgProtectBranch(repo *Repository, protectBranch *ProtectBranch, whit
 	// Make sure protectBranch.ID is not 0 for whitelists
 	if protectBranch.ID == 0 {
 		if _, err = x.Insert(protectBranch); err != nil {
-			return fmt.Errorf("insert: %v", err)
+			return errors.Newf("insert: %v", err)
 		}
 	}
 
@@ -227,7 +228,7 @@ func UpdateOrgProtectBranch(repo *Repository, protectBranch *ProtectBranch, whit
 		for _, teamID := range validTeamIDs {
 			members, err := GetTeamMembers(teamID)
 			if err != nil {
-				return fmt.Errorf("GetTeamMembers [team_id: %d]: %v", teamID, err)
+				return errors.Newf("GetTeamMembers [team_id: %d]: %v", teamID, err)
 			}
 
 			for i := range members {
@@ -253,15 +254,15 @@ func UpdateOrgProtectBranch(repo *Repository, protectBranch *ProtectBranch, whit
 	}
 
 	if _, err = sess.ID(protectBranch.ID).AllCols().Update(protectBranch); err != nil {
-		return fmt.Errorf("Update: %v", err)
+		return errors.Newf("Update: %v", err)
 	}
 
 	// Refresh whitelists
 	if hasUsersChanged || hasTeamsChanged {
 		if _, err = sess.Delete(&ProtectBranchWhitelist{ProtectBranchID: protectBranch.ID}); err != nil {
-			return fmt.Errorf("delete old protect branch whitelists: %v", err)
+			return errors.Newf("delete old protect branch whitelists: %v", err)
 		} else if _, err = sess.Insert(whitelists); err != nil {
-			return fmt.Errorf("insert new protect branch whitelists: %v", err)
+			return errors.Newf("insert new protect branch whitelists: %v", err)
 		}
 	}
 

internal/database/repo_collaboration.go

@@ -1,10 +1,9 @@
 package database
 
 import (
-	"fmt"
-
 	log "unknwon.dev/clog/v2"
 
+	"github.com/cockroachdb/errors"
 	api "github.com/gogs/go-gogs-client"
 )
 
@@ -71,7 +70,7 @@ func (r *Repository) AddCollaborator(u *User) error {
 	if _, err = sess.Insert(collaboration); err != nil {
 		return err
 	} else if err = r.recalculateAccesses(sess); err != nil {
-		return fmt.Errorf("recalculateAccesses [repo_id: %v]: %v", r.ID, err)
+		return errors.Newf("recalculateAccesses [repo_id: %v]: %v", r.ID, err)
 	}
 
 	return sess.Commit()
@@ -102,7 +101,7 @@ func (c *Collaborator) APIFormat() *api.Collaborator {
 func (r *Repository) getCollaborators(e Engine) ([]*Collaborator, error) {
 	collaborations, err := r.getCollaborations(e)
 	if err != nil {
-		return nil, fmt.Errorf("getCollaborations: %v", err)
+		return nil, errors.Newf("getCollaborations: %v", err)
 	}
 
 	collaborators := make([]*Collaborator, len(collaborations))
@@ -137,7 +136,7 @@ func (r *Repository) ChangeCollaborationAccessMode(userID int64, mode AccessMode
 	}
 	has, err := x.Get(collaboration)
 	if err != nil {
-		return fmt.Errorf("get collaboration: %v", err)
+		return errors.Newf("get collaboration: %v", err)
 	} else if !has {
 		return nil
 	}
@@ -151,7 +150,7 @@ func (r *Repository) ChangeCollaborationAccessMode(userID int64, mode AccessMode
 	if r.Owner.IsOrganization() {
 		teams, err := GetUserTeams(r.OwnerID, userID)
 		if err != nil {
-			return fmt.Errorf("GetUserTeams: [org_id: %d, user_id: %d]: %v", r.OwnerID, userID, err)
+			return errors.Newf("GetUserTeams: [org_id: %d, user_id: %d]: %v", r.OwnerID, userID, err)
 		}
 		for i := range teams {
 			if mode < teams[i].Authorize {
@@ -167,7 +166,7 @@ func (r *Repository) ChangeCollaborationAccessMode(userID int64, mode AccessMode
 	}
 
 	if _, err = sess.ID(collaboration.ID).AllCols().Update(collaboration); err != nil {
-		return fmt.Errorf("update collaboration: %v", err)
+		return errors.Newf("update collaboration: %v", err)
 	}
 
 	access := &Access{
@@ -176,7 +175,7 @@ func (r *Repository) ChangeCollaborationAccessMode(userID int64, mode AccessMode
 	}
 	has, err = sess.Get(access)
 	if err != nil {
-		return fmt.Errorf("get access record: %v", err)
+		return errors.Newf("get access record: %v", err)
 	}
 	if has {
 		_, err = sess.Exec("UPDATE access SET mode = ? WHERE user_id = ? AND repo_id = ?", mode, userID, r.ID)
@@ -185,7 +184,7 @@ func (r *Repository) ChangeCollaborationAccessMode(userID int64, mode AccessMode
 		_, err = sess.Insert(access)
 	}
 	if err != nil {
-		return fmt.Errorf("update/insert access table: %v", err)
+		return errors.Newf("update/insert access table: %v", err)
 	}
 
 	return sess.Commit()

internal/database/repo_editor.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	gouuid "github.com/satori/go.uuid"
 	"github.com/unknwon/com"
 
@@ -97,7 +97,7 @@ func discardLocalRepoBranchChanges(localPath, branch string) error {
 
 	rev := "origin/" + branch
 	if err := git.Reset(localPath, rev, git.ResetOptions{Hard: true}); err != nil {
-		return fmt.Errorf("reset [revision: %s]: %v", rev, err)
+		return errors.Newf("reset [revision: %s]: %v", rev, err)
 	}
 	return nil
 }
@@ -112,7 +112,7 @@ func (r *Repository) CheckoutNewBranch(oldBranch, newBranch string) error {
 		BaseBranch: oldBranch,
 		Timeout:    time.Duration(conf.Git.Timeout.Pull) * time.Second,
 	}); err != nil {
-		return fmt.Errorf("checkout [base: %s, new: %s]: %v", oldBranch, newBranch, err)
+		return errors.Newf("checkout [base: %s, new: %s]: %v", oldBranch, newBranch, err)
 	}
 	return nil
 }
@@ -151,9 +151,9 @@ func (r *Repository) UpdateRepoFile(doer *User, opts UpdateRepoFileOptions) erro
 	defer repoWorkingPool.CheckOut(com.ToStr(r.ID))
 
 	if err := r.DiscardLocalRepoBranchChanges(opts.OldBranch); err != nil {
-		return fmt.Errorf("discard local repo branch[%s] changes: %v", opts.OldBranch, err)
+		return errors.Newf("discard local repo branch[%s] changes: %v", opts.OldBranch, err)
 	} else if err = r.UpdateLocalCopyBranch(opts.OldBranch); err != nil {
-		return fmt.Errorf("update local copy branch[%s]: %v", opts.OldBranch, err)
+		return errors.Newf("update local copy branch[%s]: %v", opts.OldBranch, err)
 	}
 
 	localPath := r.LocalCopyPath()
@@ -176,12 +176,12 @@ func (r *Repository) UpdateRepoFile(doer *User, opts UpdateRepoFileOptions) erro
 			if err := git.DeleteBranch(localPath, opts.NewBranch, git.DeleteBranchOptions{
 				Force: true,
 			}); err != nil {
-				return fmt.Errorf("delete branch %q: %v", opts.NewBranch, err)
+				return errors.Newf("delete branch %q: %v", opts.NewBranch, err)
 			}
 		}
 
 		if err := r.CheckoutNewBranch(opts.OldBranch, opts.NewBranch); err != nil {
-			return fmt.Errorf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
+			return errors.Newf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
 		}
 	}
 
@@ -204,11 +204,11 @@ func (r *Repository) UpdateRepoFile(doer *User, opts UpdateRepoFileOptions) erro
 	}
 
 	if err := os.WriteFile(newFilePath, []byte(opts.Content), 0o600); err != nil {
-		return fmt.Errorf("write file: %v", err)
+		return errors.Newf("write file: %v", err)
 	}
 
 	if err := git.Add(localPath, git.AddOptions{All: true}); err != nil {
-		return fmt.Errorf("git add --all: %v", err)
+		return errors.Newf("git add --all: %v", err)
 	}
 	err := git.CreateCommit(
 		localPath,
@@ -220,7 +220,7 @@ func (r *Repository) UpdateRepoFile(doer *User, opts UpdateRepoFileOptions) erro
 		opts.Message,
 	)
 	if err != nil {
-		return fmt.Errorf("commit changes on %q: %v", localPath, err)
+		return errors.Newf("commit changes on %q: %v", localPath, err)
 	}
 
 	err = git.Push(localPath, "origin", opts.NewBranch,
@@ -238,7 +238,7 @@ func (r *Repository) UpdateRepoFile(doer *User, opts UpdateRepoFileOptions) erro
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("git push origin %s: %v", opts.NewBranch, err)
+		return errors.Newf("git push origin %s: %v", opts.NewBranch, err)
 	}
 	return nil
 }
@@ -254,9 +254,9 @@ func (r *Repository) GetDiffPreview(branch, treePath, content string) (*gitutil.
 	defer repoWorkingPool.CheckOut(com.ToStr(r.ID))
 
 	if err := r.DiscardLocalRepoBranchChanges(branch); err != nil {
-		return nil, fmt.Errorf("discard local repo branch[%s] changes: %v", branch, err)
+		return nil, errors.Newf("discard local repo branch[%s] changes: %v", branch, err)
 	} else if err = r.UpdateLocalCopyBranch(branch); err != nil {
-		return nil, fmt.Errorf("update local copy branch[%s]: %v", branch, err)
+		return nil, errors.Newf("update local copy branch[%s]: %v", branch, err)
 	}
 
 	localPath := r.LocalCopyPath()
@@ -271,7 +271,7 @@ func (r *Repository) GetDiffPreview(branch, treePath, content string) (*gitutil.
 	if err := os.MkdirAll(path.Dir(filePath), os.ModePerm); err != nil {
 		return nil, errors.Wrap(err, "create parent directories")
 	} else if err = os.WriteFile(filePath, []byte(content), 0o600); err != nil {
-		return nil, fmt.Errorf("write file: %v", err)
+		return nil, errors.Newf("write file: %v", err)
 	}
 
 	// 🚨 SECURITY: Prevent including unintended options in the path to the Git command.
@@ -281,11 +281,11 @@ func (r *Repository) GetDiffPreview(branch, treePath, content string) (*gitutil.
 
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		return nil, fmt.Errorf("get stdout pipe: %v", err)
+		return nil, errors.Newf("get stdout pipe: %v", err)
 	}
 
 	if err = cmd.Start(); err != nil {
-		return nil, fmt.Errorf("start: %v", err)
+		return nil, errors.Newf("start: %v", err)
 	}
 
 	pid := process.Add(fmt.Sprintf("GetDiffPreview [repo_path: %s]", r.RepoPath()), cmd)
@@ -293,10 +293,10 @@ func (r *Repository) GetDiffPreview(branch, treePath, content string) (*gitutil.
 
 	diff, err := gitutil.ParseDiff(stdout, conf.Git.MaxDiffFiles, conf.Git.MaxDiffLines, conf.Git.MaxDiffLineChars)
 	if err != nil {
-		return nil, fmt.Errorf("parse diff: %v", err)
+		return nil, errors.Newf("parse diff: %v", err)
 	}
 	if err = cmd.Wait(); err != nil {
-		return nil, fmt.Errorf("wait: %v", err)
+		return nil, errors.Newf("wait: %v", err)
 	}
 	return diff, nil
 }
@@ -327,9 +327,9 @@ func (r *Repository) DeleteRepoFile(doer *User, opts DeleteRepoFileOptions) (err
 	defer repoWorkingPool.CheckOut(com.ToStr(r.ID))
 
 	if err = r.DiscardLocalRepoBranchChanges(opts.OldBranch); err != nil {
-		return fmt.Errorf("discard local r branch[%s] changes: %v", opts.OldBranch, err)
+		return errors.Newf("discard local r branch[%s] changes: %v", opts.OldBranch, err)
 	} else if err = r.UpdateLocalCopyBranch(opts.OldBranch); err != nil {
-		return fmt.Errorf("update local copy branch[%s]: %v", opts.OldBranch, err)
+		return errors.Newf("update local copy branch[%s]: %v", opts.OldBranch, err)
 	}
 
 	localPath := r.LocalCopyPath()
@@ -342,17 +342,17 @@ func (r *Repository) DeleteRepoFile(doer *User, opts DeleteRepoFileOptions) (err
 
 	if opts.OldBranch != opts.NewBranch {
 		if err := r.CheckoutNewBranch(opts.OldBranch, opts.NewBranch); err != nil {
-			return fmt.Errorf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
+			return errors.Newf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
 		}
 	}
 
 	filePath := path.Join(localPath, opts.TreePath)
 	if err = os.Remove(filePath); err != nil {
-		return fmt.Errorf("remove file %q: %v", opts.TreePath, err)
+		return errors.Newf("remove file %q: %v", opts.TreePath, err)
 	}
 
 	if err = git.Add(localPath, git.AddOptions{All: true}); err != nil {
-		return fmt.Errorf("git add --all: %v", err)
+		return errors.Newf("git add --all: %v", err)
 	}
 
 	err = git.CreateCommit(
@@ -365,7 +365,7 @@ func (r *Repository) DeleteRepoFile(doer *User, opts DeleteRepoFileOptions) (err
 		opts.Message,
 	)
 	if err != nil {
-		return fmt.Errorf("commit changes to %q: %v", localPath, err)
+		return errors.Newf("commit changes to %q: %v", localPath, err)
 	}
 
 	err = git.Push(localPath, "origin", opts.NewBranch,
@@ -383,7 +383,7 @@ func (r *Repository) DeleteRepoFile(doer *User, opts DeleteRepoFileOptions) (err
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("git push origin %s: %v", opts.NewBranch, err)
+		return errors.Newf("git push origin %s: %v", opts.NewBranch, err)
 	}
 	return nil
 }
@@ -416,7 +416,7 @@ func (upload *Upload) LocalPath() string {
 // NewUpload creates a new upload object.
 func NewUpload(name string, buf []byte, file multipart.File) (_ *Upload, err error) {
 	if tool.IsMaliciousPath(name) {
-		return nil, fmt.Errorf("malicious path detected: %s", name)
+		return nil, errors.Newf("malicious path detected: %s", name)
 	}
 
 	upload := &Upload{
@@ -426,19 +426,19 @@ func NewUpload(name string, buf []byte, file multipart.File) (_ *Upload, err err
 
 	localPath := upload.LocalPath()
 	if err = os.MkdirAll(path.Dir(localPath), os.ModePerm); err != nil {
-		return nil, fmt.Errorf("mkdir all: %v", err)
+		return nil, errors.Newf("mkdir all: %v", err)
 	}
 
 	fw, err := os.Create(localPath)
 	if err != nil {
-		return nil, fmt.Errorf("create: %v", err)
+		return nil, errors.Newf("create: %v", err)
 	}
 	defer func() { _ = fw.Close() }()
 
 	if _, err = fw.Write(buf); err != nil {
-		return nil, fmt.Errorf("write: %v", err)
+		return nil, errors.Newf("write: %v", err)
 	} else if _, err = io.Copy(fw, file); err != nil {
-		return nil, fmt.Errorf("copy: %v", err)
+		return nil, errors.Newf("copy: %v", err)
 	}
 
 	if _, err := x.Insert(upload); err != nil {
@@ -485,7 +485,7 @@ func DeleteUploads(uploads ...*Upload) (err error) {
 		ids[i] = uploads[i].ID
 	}
 	if _, err = sess.In("id", ids).Delete(new(Upload)); err != nil {
-		return fmt.Errorf("delete uploads: %v", err)
+		return errors.Newf("delete uploads: %v", err)
 	}
 
 	for _, upload := range uploads {
@@ -495,7 +495,7 @@ func DeleteUploads(uploads ...*Upload) (err error) {
 		}
 
 		if err := os.Remove(localPath); err != nil {
-			return fmt.Errorf("remove upload: %v", err)
+			return errors.Newf("remove upload: %v", err)
 		}
 	}
 
@@ -512,11 +512,11 @@ func DeleteUploadByUUID(uuid string) error {
 		if IsErrUploadNotExist(err) {
 			return nil
 		}
-		return fmt.Errorf("get upload by UUID[%s]: %v", uuid, err)
+		return errors.Newf("get upload by UUID[%s]: %v", uuid, err)
 	}
 
 	if err := DeleteUpload(upload); err != nil {
-		return fmt.Errorf("delete upload: %v", err)
+		return errors.Newf("delete upload: %v", err)
 	}
 
 	return nil
@@ -558,21 +558,21 @@ func (r *Repository) UploadRepoFiles(doer *User, opts UploadRepoFileOptions) err
 
 	uploads, err := GetUploadsByUUIDs(opts.Files)
 	if err != nil {
-		return fmt.Errorf("get uploads by UUIDs[%v]: %v", opts.Files, err)
+		return errors.Newf("get uploads by UUIDs[%v]: %v", opts.Files, err)
 	}
 
 	repoWorkingPool.CheckIn(com.ToStr(r.ID))
 	defer repoWorkingPool.CheckOut(com.ToStr(r.ID))
 
 	if err = r.DiscardLocalRepoBranchChanges(opts.OldBranch); err != nil {
-		return fmt.Errorf("discard local r branch[%s] changes: %v", opts.OldBranch, err)
+		return errors.Newf("discard local r branch[%s] changes: %v", opts.OldBranch, err)
 	} else if err = r.UpdateLocalCopyBranch(opts.OldBranch); err != nil {
-		return fmt.Errorf("update local copy branch[%s]: %v", opts.OldBranch, err)
+		return errors.Newf("update local copy branch[%s]: %v", opts.OldBranch, err)
 	}
 
 	if opts.OldBranch != opts.NewBranch {
 		if err = r.CheckoutNewBranch(opts.OldBranch, opts.NewBranch); err != nil {
-			return fmt.Errorf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
+			return errors.Newf("checkout new branch[%s] from old branch[%s]: %v", opts.NewBranch, opts.OldBranch, err)
 		}
 	}
 
@@ -602,16 +602,16 @@ func (r *Repository) UploadRepoFiles(doer *User, opts UploadRepoFileOptions) err
 		// 🚨 SECURITY: Prevent updating files in surprising place, check if the target
 		// is a symlink.
 		if osutil.IsSymlink(targetPath) {
-			return fmt.Errorf("cannot overwrite symbolic link: %s", upload.Name)
+			return errors.Newf("cannot overwrite symbolic link: %s", upload.Name)
 		}
 
 		if err = com.Copy(tmpPath, targetPath); err != nil {
-			return fmt.Errorf("copy: %v", err)
+			return errors.Newf("copy: %v", err)
 		}
 	}
 
 	if err = git.Add(localPath, git.AddOptions{All: true}); err != nil {
-		return fmt.Errorf("git add --all: %v", err)
+		return errors.Newf("git add --all: %v", err)
 	}
 
 	err = git.CreateCommit(
@@ -624,7 +624,7 @@ func (r *Repository) UploadRepoFiles(doer *User, opts UploadRepoFileOptions) err
 		opts.Message,
 	)
 	if err != nil {
-		return fmt.Errorf("commit changes on %q: %v", localPath, err)
+		return errors.Newf("commit changes on %q: %v", localPath, err)
 	}
 
 	err = git.Push(localPath, "origin", opts.NewBranch,
@@ -642,7 +642,7 @@ func (r *Repository) UploadRepoFiles(doer *User, opts UploadRepoFileOptions) err
 		},
 	)
 	if err != nil {
-		return fmt.Errorf("git push origin %s: %v", opts.NewBranch, err)
+		return errors.Newf("git push origin %s: %v", opts.NewBranch, err)
 	}
 
 	return DeleteUploads(uploads...)

internal/database/repo_tag.go

@@ -1,8 +1,7 @@
 package database
 
 import (
-	"fmt"
-
+	"github.com/cockroachdb/errors"
 	"github.com/gogs/git-module"
 )
 
@@ -17,7 +16,7 @@ type Tag struct {
 func (ta *Tag) GetCommit() (*git.Commit, error) {
 	gitRepo, err := git.Open(ta.RepoPath)
 	if err != nil {
-		return nil, fmt.Errorf("open repository: %v", err)
+		return nil, errors.Newf("open repository: %v", err)
 	}
 	return gitRepo.TagCommit(ta.Name)
 }
@@ -25,12 +24,12 @@ func (ta *Tag) GetCommit() (*git.Commit, error) {
 func GetTagsByPath(path string) ([]*Tag, error) {
 	gitRepo, err := git.Open(path)
 	if err != nil {
-		return nil, fmt.Errorf("open repository: %v", err)
+		return nil, errors.Newf("open repository: %v", err)
 	}
 
 	names, err := gitRepo.Tags()
 	if err != nil {
-		return nil, fmt.Errorf("list tags")
+		return nil, errors.Newf("list tags: %v", err)
 	}
 
 	tags := make([]*Tag, len(names))

internal/database/repositories.go

@@ -6,8 +6,8 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	api "github.com/gogs/go-gogs-client"
-	"github.com/pkg/errors"
 	"gorm.io/gorm"
 
 	"gogs.io/gogs/internal/errutil"

internal/database/schemadoc/main.go

@@ -7,8 +7,8 @@ import (
 	"sort"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	"github.com/olekukonko/tablewriter"
-	"github.com/pkg/errors"
 	"gopkg.in/DATA-DOG/go-sqlmock.v2"
 	"gorm.io/driver/mysql"
 	"gorm.io/driver/postgres"

internal/database/ssh_key.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"math/big"
 	"os"
@@ -14,6 +13,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/unknwon/com"
 	"golang.org/x/crypto/ssh"
 	log "unknwon.dev/clog/v2"
@@ -92,12 +92,12 @@ func (k *PublicKey) IsDeployKey() bool {
 func extractTypeFromBase64Key(key string) (string, error) {
 	b, err := base64.StdEncoding.DecodeString(key)
 	if err != nil || len(b) < 4 {
-		return "", fmt.Errorf("invalid key format: %v", err)
+		return "", errors.Newf("invalid key format: %v", err)
 	}
 
 	keyLength := int(binary.BigEndian.Uint32(b))
 	if len(b) < 4+keyLength {
-		return "", fmt.Errorf("invalid key format: not enough length %d", keyLength)
+		return "", errors.Newf("invalid key format: not enough length %d", keyLength)
 	}
 
 	return string(b[4 : 4+keyLength]), nil
@@ -141,12 +141,12 @@ func parseKeyString(content string) (string, error) {
 		// If keyType is not given, extract it from content. If given, validate it.
 		t, err := extractTypeFromBase64Key(keyContent)
 		if err != nil {
-			return "", fmt.Errorf("extractTypeFromBase64Key: %v", err)
+			return "", errors.Newf("extractTypeFromBase64Key: %v", err)
 		}
 		if keyType == "" {
 			keyType = t
 		} else if keyType != t {
-			return "", fmt.Errorf("key type and content does not match: %s - %s", keyType, t)
+			return "", errors.Newf("key type and content does not match: %s - %s", keyType, t)
 		}
 	} else {
 		// Parse SSH2 file format.
@@ -166,7 +166,7 @@ func parseKeyString(content string) (string, error) {
 
 		t, err := extractTypeFromBase64Key(keyContent)
 		if err != nil {
-			return "", fmt.Errorf("extractTypeFromBase64Key: %v", err)
+			return "", errors.Newf("extractTypeFromBase64Key: %v", err)
 		}
 		keyType = t
 	}
@@ -178,12 +178,12 @@ func parseKeyString(content string) (string, error) {
 func writeTmpKeyFile(content string) (string, error) {
 	tmpFile, err := os.CreateTemp(conf.SSH.KeyTestPath, "gogs_keytest")
 	if err != nil {
-		return "", fmt.Errorf("TempFile: %v", err)
+		return "", errors.Newf("TempFile: %v", err)
 	}
 	defer tmpFile.Close()
 
 	if _, err = tmpFile.WriteString(content); err != nil {
-		return "", fmt.Errorf("WriteString: %v", err)
+		return "", errors.Newf("WriteString: %v", err)
 	}
 	return tmpFile.Name(), nil
 }
@@ -192,13 +192,13 @@ func writeTmpKeyFile(content string) (string, error) {
 func SSHKeyGenParsePublicKey(key string) (string, int, error) {
 	tmpName, err := writeTmpKeyFile(key)
 	if err != nil {
-		return "", 0, fmt.Errorf("writeTmpKeyFile: %v", err)
+		return "", 0, errors.Newf("writeTmpKeyFile: %v", err)
 	}
 	defer os.Remove(tmpName)
 
 	stdout, stderr, err := process.Exec("SSHKeyGenParsePublicKey", conf.SSH.KeygenPath, "-lf", tmpName)
 	if err != nil {
-		return "", 0, fmt.Errorf("fail to parse public key: %s - %s", err, stderr)
+		return "", 0, errors.Newf("fail to parse public key: %s - %s", err, stderr)
 	}
 	if strings.Contains(stdout, "is not a public key file") {
 		return "", 0, ErrKeyUnableVerify{stdout}
@@ -206,7 +206,7 @@ func SSHKeyGenParsePublicKey(key string) (string, int, error) {
 
 	fields := strings.Split(stdout, " ")
 	if len(fields) < 4 {
-		return "", 0, fmt.Errorf("invalid public key line: %s", stdout)
+		return "", 0, errors.Newf("invalid public key line: %s", stdout)
 	}
 
 	keyType := strings.Trim(fields[len(fields)-1], "()\r\n")
@@ -217,7 +217,7 @@ func SSHKeyGenParsePublicKey(key string) (string, int, error) {
 func SSHNativeParsePublicKey(keyLine string) (string, int, error) {
 	fields := strings.Fields(keyLine)
 	if len(fields) < 2 {
-		return "", 0, fmt.Errorf("not enough fields in public key line: %s", keyLine)
+		return "", 0, errors.Newf("not enough fields in public key line: %s", keyLine)
 	}
 
 	raw, err := base64.StdEncoding.DecodeString(fields[1])
@@ -230,7 +230,7 @@ func SSHNativeParsePublicKey(keyLine string) (string, int, error) {
 		if strings.Contains(err.Error(), "ssh: unknown key algorithm") {
 			return "", 0, ErrKeyUnableVerify{err.Error()}
 		}
-		return "", 0, fmt.Errorf("ParsePublicKey: %v", err)
+		return "", 0, errors.Newf("ParsePublicKey: %v", err)
 	}
 
 	// The ssh library can parse the key, so next we find out what key exactly we have.
@@ -265,7 +265,7 @@ func SSHNativeParsePublicKey(keyLine string) (string, int, error) {
 	case ssh.KeyAlgoED25519:
 		return "ed25519", 256, nil
 	}
-	return "", 0, fmt.Errorf("unsupported key length detection for type: %s", pkey.Type())
+	return "", 0, errors.Newf("unsupported key length detection for type: %s", pkey.Type())
 }
 
 // CheckPublicKeyString checks if the given public key string is recognized by SSH.
@@ -305,16 +305,16 @@ func CheckPublicKeyString(content string) (_ string, err error) {
 		keyType, length, err = SSHKeyGenParsePublicKey(content)
 	}
 	if err != nil {
-		return "", fmt.Errorf("%s: %v", fnName, err)
+		return "", errors.Newf("%s: %v", fnName, err)
 	}
 	log.Trace("Key info [native: %v]: %s-%d", conf.SSH.StartBuiltinServer, keyType, length)
 
 	if minLen, found := conf.SSH.MinimumKeySizes[keyType]; found && length >= minLen {
 		return content, nil
 	} else if found && length < minLen {
-		return "", fmt.Errorf("key length is not enough: got %d, needs %d", length, minLen)
+		return "", errors.Newf("key length is not enough: got %d, needs %d", length, minLen)
 	}
-	return "", fmt.Errorf("key type is not allowed: %s", keyType)
+	return "", errors.Newf("key type is not allowed: %s", keyType)
 }
 
 // appendAuthorizedKeysToFile appends new SSH keys' content to authorized_keys file.
@@ -378,7 +378,7 @@ func addKey(e Engine, key *PublicKey) (err error) {
 
 	stdout, stderr, err := process.Exec("AddPublicKey", conf.SSH.KeygenPath, "-lf", tmpPath)
 	if err != nil {
-		return fmt.Errorf("fail to parse public key: %s - %s", err, stderr)
+		return errors.Newf("fail to parse public key: %s - %s", err, stderr)
 	} else if len(stdout) < 2 {
 		return errors.New("not enough output for calculating fingerprint: " + stdout)
 	}
@@ -425,7 +425,7 @@ func AddPublicKey(ownerID int64, name, content string) (*PublicKey, error) {
 		Type:    KeyTypeUser,
 	}
 	if err = addKey(sess, key); err != nil {
-		return nil, fmt.Errorf("addKey: %v", err)
+		return nil, errors.Newf("addKey: %v", err)
 	}
 
 	return key, sess.Commit()
@@ -486,7 +486,7 @@ func DeletePublicKey(doer *User, id int64) (err error) {
 		if IsErrKeyNotExist(err) {
 			return nil
 		}
-		return fmt.Errorf("GetPublicKeyByID: %v", err)
+		return errors.Newf("GetPublicKeyByID: %v", err)
 	}
 
 	// Check if user has access to delete this key.
@@ -671,13 +671,13 @@ func AddDeployKey(repoID int64, name, content string) (*DeployKey, error) {
 	// First time use this deploy key.
 	if !has {
 		if err = addKey(sess, pkey); err != nil {
-			return nil, fmt.Errorf("addKey: %v", err)
+			return nil, errors.Newf("addKey: %v", err)
 		}
 	}
 
 	key, err := addDeployKey(sess, pkey.ID, repoID, name, pkey.Fingerprint)
 	if err != nil {
-		return nil, fmt.Errorf("addDeployKey: %v", err)
+		return nil, errors.Newf("addDeployKey: %v", err)
 	}
 
 	return key, sess.Commit()
@@ -742,14 +742,14 @@ func DeleteDeployKey(doer *User, id int64) error {
 		if IsErrDeployKeyNotExist(err) {
 			return nil
 		}
-		return fmt.Errorf("GetDeployKeyByID: %v", err)
+		return errors.Newf("GetDeployKeyByID: %v", err)
 	}
 
 	// Check if user has access to delete this key.
 	if !doer.IsAdmin {
 		repo, err := GetRepositoryByID(key.RepoID)
 		if err != nil {
-			return fmt.Errorf("GetRepositoryByID: %v", err)
+			return errors.Newf("GetRepositoryByID: %v", err)
 		}
 		if !Handle.Permissions().Authorize(context.TODO(), doer.ID, repo.ID, AccessModeAdmin,
 			AccessModeOptions{
@@ -768,7 +768,7 @@ func DeleteDeployKey(doer *User, id int64) error {
 	}
 
 	if _, err = sess.ID(key.ID).Delete(new(DeployKey)); err != nil {
-		return fmt.Errorf("delete deploy key [%d]: %v", key.ID, err)
+		return errors.Newf("delete deploy key [%d]: %v", key.ID, err)
 	}
 
 	// Check if this is the last reference to same key content.

internal/database/two_factor.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/pquerna/otp/totp"
 	"github.com/unknwon/com"
 
@@ -26,11 +27,11 @@ type TwoFactor struct {
 func (t *TwoFactor) ValidateTOTP(passcode string) (bool, error) {
 	secret, err := base64.StdEncoding.DecodeString(t.Secret)
 	if err != nil {
-		return false, fmt.Errorf("DecodeString: %v", err)
+		return false, errors.Newf("DecodeString: %v", err)
 	}
 	decryptSecret, err := com.AESGCMDecrypt(cryptoutil.MD5Bytes(conf.Security.SecretKey), secret)
 	if err != nil {
-		return false, fmt.Errorf("AESGCMDecrypt: %v", err)
+		return false, errors.Newf("AESGCMDecrypt: %v", err)
 	}
 	return totp.Validate(passcode, string(decryptSecret)), nil
 }
@@ -44,9 +45,9 @@ func DeleteTwoFactor(userID int64) (err error) {
 	}
 
 	if _, err = sess.Where("user_id = ?", userID).Delete(new(TwoFactor)); err != nil {
-		return fmt.Errorf("delete two-factor: %v", err)
+		return errors.Newf("delete two-factor: %v", err)
 	} else if err = deleteRecoveryCodesByUserID(sess, userID); err != nil {
-		return fmt.Errorf("deleteRecoveryCodesByUserID: %v", err)
+		return errors.Newf("deleteRecoveryCodesByUserID: %v", err)
 	}
 
 	return sess.Commit()
@@ -75,7 +76,7 @@ func deleteRecoveryCodesByUserID(e Engine, userID int64) error {
 func RegenerateRecoveryCodes(userID int64) error {
 	recoveryCodes, err := generateRecoveryCodes(userID, 10)
 	if err != nil {
-		return fmt.Errorf("generateRecoveryCodes: %v", err)
+		return errors.Newf("generateRecoveryCodes: %v", err)
 	}
 
 	sess := x.NewSession()
@@ -85,9 +86,9 @@ func RegenerateRecoveryCodes(userID int64) error {
 	}
 
 	if err = deleteRecoveryCodesByUserID(sess, userID); err != nil {
-		return fmt.Errorf("deleteRecoveryCodesByUserID: %v", err)
+		return errors.Newf("deleteRecoveryCodesByUserID: %v", err)
 	} else if _, err = sess.Insert(recoveryCodes); err != nil {
-		return fmt.Errorf("insert new recovery codes: %v", err)
+		return errors.Newf("insert new recovery codes: %v", err)
 	}
 
 	return sess.Commit()
@@ -111,14 +112,14 @@ func UseRecoveryCode(_ int64, code string) error {
 	recoveryCode := new(TwoFactorRecoveryCode)
 	has, err := x.Where("code = ?", code).And("is_used = ?", false).Get(recoveryCode)
 	if err != nil {
-		return fmt.Errorf("get unused code: %v", err)
+		return errors.Newf("get unused code: %v", err)
 	} else if !has {
 		return ErrTwoFactorRecoveryCodeNotFound{Code: code}
 	}
 
 	recoveryCode.IsUsed = true
 	if _, err = x.Id(recoveryCode.ID).Cols("is_used").Update(recoveryCode); err != nil {
-		return fmt.Errorf("mark code as used: %v", err)
+		return errors.Newf("mark code as used: %v", err)
 	}
 
 	return nil

internal/database/two_factors.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/pkg/errors"
+	"github.com/cockroachdb/errors"
 	"gorm.io/gorm"
 	log "unknwon.dev/clog/v2"
 

internal/database/update.go

@@ -2,12 +2,11 @@ package database
 
 import (
 	"context"
-	"fmt"
 	"os/exec"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	"github.com/gogs/git-module"
-	"github.com/pkg/errors"
 )
 
 // CommitToPushCommit transforms a git.Commit to PushCommit type.
@@ -53,7 +52,7 @@ func PushUpdate(opts PushUpdateOptions) (err error) {
 	isNewRef := strings.HasPrefix(opts.OldCommitID, git.EmptyID)
 	isDelRef := strings.HasPrefix(opts.NewCommitID, git.EmptyID)
 	if isNewRef && isDelRef {
-		return fmt.Errorf("both old and new revisions are %q", git.EmptyID)
+		return errors.Newf("both old and new revisions are %q", git.EmptyID)
 	}
 
 	repoPath := RepoPath(opts.RepoUserName, opts.RepoName)
@@ -61,26 +60,26 @@ func PushUpdate(opts PushUpdateOptions) (err error) {
 	gitUpdate := exec.Command("git", "update-server-info")
 	gitUpdate.Dir = repoPath
 	if err = gitUpdate.Run(); err != nil {
-		return fmt.Errorf("run 'git update-server-info': %v", err)
+		return errors.Newf("run 'git update-server-info': %v", err)
 	}
 
 	gitRepo, err := git.Open(repoPath)
 	if err != nil {
-		return fmt.Errorf("open repository: %v", err)
+		return errors.Newf("open repository: %v", err)
 	}
 
 	owner, err := Handle.Users().GetByUsername(ctx, opts.RepoUserName)
 	if err != nil {
-		return fmt.Errorf("GetUserByName: %v", err)
+		return errors.Newf("GetUserByName: %v", err)
 	}
 
 	repo, err := GetRepositoryByName(owner.ID, opts.RepoName)
 	if err != nil {
-		return fmt.Errorf("GetRepositoryByName: %v", err)
+		return errors.Newf("GetRepositoryByName: %v", err)
 	}
 
 	if err = repo.UpdateSize(); err != nil {
-		return fmt.Errorf("UpdateSize: %v", err)
+		return errors.Newf("UpdateSize: %v", err)
 	}
 
 	// Push tags
@@ -106,19 +105,19 @@ func PushUpdate(opts PushUpdateOptions) (err error) {
 		// Push new branch
 		newCommit, err := gitRepo.CatFileCommit(opts.NewCommitID)
 		if err != nil {
-			return fmt.Errorf("GetCommit [commit_id: %s]: %v", opts.NewCommitID, err)
+			return errors.Newf("GetCommit [commit_id: %s]: %v", opts.NewCommitID, err)
 		}
 
 		if isNewRef {
 			commits, err = newCommit.Ancestors(git.LogOptions{MaxCount: 9})
 			if err != nil {
-				return fmt.Errorf("CommitsBeforeLimit [commit_id: %s]: %v", newCommit.ID, err)
+				return errors.Newf("CommitsBeforeLimit [commit_id: %s]: %v", newCommit.ID, err)
 			}
 			commits = append([]*git.Commit{newCommit}, commits...)
 		} else {
 			commits, err = newCommit.CommitsAfter(opts.OldCommitID)
 			if err != nil {
-				return fmt.Errorf("CommitsBeforeUntil [commit_id: %s]: %v", opts.OldCommitID, err)
+				return errors.Newf("CommitsBeforeUntil [commit_id: %s]: %v", opts.OldCommitID, err)
 			}
 		}
 	}

internal/database/users.go

@@ -9,9 +9,9 @@ import (
 	"time"
 	"unicode/utf8"
 
+	"github.com/cockroachdb/errors"
 	"github.com/go-macaron/binding"
 	api "github.com/gogs/go-gogs-client"
-	"github.com/pkg/errors"
 	"gorm.io/gorm"
 	log "unknwon.dev/clog/v2"
 
@@ -130,7 +130,7 @@ func (s *UsersStore) Authenticate(ctx context.Context, login, password string, l
 
 	// Validate username make sure it satisfies requirement.
 	if binding.AlphaDashDotPattern.MatchString(extAccount.Name) {
-		return nil, fmt.Errorf("invalid pattern for attribute 'username' [%s]: must be valid alpha or numeric or dash(-_) or dot characters", extAccount.Name)
+		return nil, errors.Newf("invalid pattern for attribute 'username' [%s]: must be valid alpha or numeric or dash(-_) or dot characters", extAccount.Name)
 	}
 
 	return s.Create(ctx, extAccount.Name, extAccount.Email,

internal/database/webhook.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	jsoniter "github.com/json-iterator/go"
 	gouuid "github.com/satori/go.uuid"
 	log "unknwon.dev/clog/v2"
@@ -605,17 +606,17 @@ func prepareHookTasks(e Engine, repo *Repository, event HookEventType, p api.Pay
 		case SLACK:
 			payloader, err = GetSlackPayload(p, event, w.Meta)
 			if err != nil {
-				return fmt.Errorf("GetSlackPayload: %v", err)
+				return errors.Newf("GetSlackPayload: %v", err)
 			}
 		case DISCORD:
 			payloader, err = GetDiscordPayload(p, event, w.Meta)
 			if err != nil {
-				return fmt.Errorf("GetDiscordPayload: %v", err)
+				return errors.Newf("GetDiscordPayload: %v", err)
 			}
 		case DINGTALK:
 			payloader, err = GetDingtalkPayload(p, event)
 			if err != nil {
-				return fmt.Errorf("GetDingtalkPayload: %v", err)
+				return errors.Newf("GetDingtalkPayload: %v", err)
 			}
 		default:
 			payloader = p
@@ -643,7 +644,7 @@ func prepareHookTasks(e Engine, repo *Repository, event HookEventType, p api.Pay
 			EventType:   event,
 			IsSSL:       w.IsSSL,
 		}); err != nil {
-			return fmt.Errorf("createHookTask: %v", err)
+			return errors.Newf("createHookTask: %v", err)
 		}
 	}
 
@@ -657,7 +658,7 @@ func prepareHookTasks(e Engine, repo *Repository, event HookEventType, p api.Pay
 func prepareWebhooks(e Engine, repo *Repository, event HookEventType, p api.Payloader) error {
 	webhooks, err := getActiveWebhooksByRepoID(e, repo.ID)
 	if err != nil {
-		return fmt.Errorf("getActiveWebhooksByRepoID [%d]: %v", repo.ID, err)
+		return errors.Newf("getActiveWebhooksByRepoID [%d]: %v", repo.ID, err)
 	}
 
 	// check if repo belongs to org and append additional webhooks
@@ -665,7 +666,7 @@ func prepareWebhooks(e Engine, repo *Repository, event HookEventType, p api.Payl
 		// get hooks for org
 		orgws, err := getActiveWebhooksByOrgID(e, repo.OwnerID)
 		if err != nil {
-			return fmt.Errorf("getActiveWebhooksByOrgID [%d]: %v", repo.OwnerID, err)
+			return errors.Newf("getActiveWebhooksByOrgID [%d]: %v", repo.OwnerID, err)
 		}
 		webhooks = append(webhooks, orgws...)
 	}
@@ -686,7 +687,7 @@ func PrepareWebhooks(repo *Repository, event HookEventType, p api.Payloader) err
 func TestWebhook(repo *Repository, event HookEventType, p api.Payloader, webhookID int64) error {
 	webhook, err := GetWebhookOfRepoByID(repo.ID, webhookID)
 	if err != nil {
-		return fmt.Errorf("GetWebhookOfRepoByID [repo_id: %d, id: %d]: %v", repo.ID, webhookID, err)
+		return errors.Newf("GetWebhookOfRepoByID [repo_id: %d, id: %d]: %v", repo.ID, webhookID, err)
 	}
 	return prepareHookTasks(x, repo, event, p, []*Webhook{webhook})
 }

internal/database/webhook_dingtalk.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 
 	"github.com/gogs/git-module"
 	api "github.com/gogs/go-gogs-client"

internal/database/webhook_discord.go

@@ -5,8 +5,8 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 
 	"github.com/gogs/git-module"
 	api "github.com/gogs/go-gogs-client"
@@ -370,7 +370,7 @@ func getDiscordReleasePayload(p *api.ReleasePayload) *DiscordPayload {
 func GetDiscordPayload(p api.Payloader, event HookEventType, meta string) (payload *DiscordPayload, err error) {
 	slack := &SlackMeta{}
 	if err := jsoniter.Unmarshal([]byte(meta), &slack); err != nil {
-		return nil, fmt.Errorf("jsoniter.Unmarshal: %v", err)
+		return nil, errors.Newf("jsoniter.Unmarshal: %v", err)
 	}
 
 	switch event {

internal/database/webhook_slack.go

@@ -4,8 +4,8 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/cockroachdb/errors"
 	jsoniter "github.com/json-iterator/go"
-	"github.com/pkg/errors"
 
 	"github.com/gogs/git-module"
 	api "github.com/gogs/go-gogs-client"
@@ -287,7 +287,7 @@ func getSlackReleasePayload(p *api.ReleasePayload) *SlackPayload {
 func GetSlackPayload(p api.Payloader, event HookEventType, meta string) (payload *SlackPayload, err error) {
 	slack := &SlackMeta{}
 	if err := jsoniter.Unmarshal([]byte(meta), &slack); err != nil {
-		return nil, fmt.Errorf("unmarshal: %v", err)
+		return nil, errors.Newf("unmarshal: %v", err)
 	}
 
 	switch event {

internal/database/wiki.go

@@ -1,7 +1,6 @@
 package database
 
 import (
-	"fmt"
 	"net/url"
 	"os"
 	"path"
@@ -9,6 +8,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/cockroachdb/errors"
 	"github.com/unknwon/com"
 
 	"github.com/gogs/git-module"
@@ -71,9 +71,9 @@ func (r *Repository) InitWiki() error {
 	}
 
 	if err := git.Init(r.WikiPath(), git.InitOptions{Bare: true}); err != nil {
-		return fmt.Errorf("init repository: %v", err)
+		return errors.Newf("init repository: %v", err)
 	} else if err = createDelegateHooks(r.WikiPath()); err != nil {
-		return fmt.Errorf("createDelegateHooks: %v", err)
+		return errors.Newf("createDelegateHooks: %v", err)
 	}
 	return nil
 }
@@ -98,14 +98,14 @@ func (r *Repository) updateWikiPage(doer *User, oldTitle, title, content, messag
 	defer wikiWorkingPool.CheckOut(com.ToStr(r.ID))
 
 	if err = r.InitWiki(); err != nil {
-		return fmt.Errorf("InitWiki: %v", err)
+		return errors.Newf("InitWiki: %v", err)
 	}
 
 	localPath := r.LocalWikiPath()
 	if err = discardLocalWikiChanges(localPath); err != nil {
-		return fmt.Errorf("discardLocalWikiChanges: %v", err)
+		return errors.Newf("discardLocalWikiChanges: %v", err)
 	} else if err = r.UpdateLocalWiki(); err != nil {
-		return fmt.Errorf("UpdateLocalWiki: %v", err)
+		return errors.Newf("UpdateLocalWiki: %v", err)
 	}
 
 	title = ToWikiPageName(title)
@@ -128,14 +128,14 @@ func (r *Repository) updateWikiPage(doer *User, oldTitle, title, content, messag
 	os.Remove(filename)
 
 	if err = os.WriteFile(filename, []byte(content), 0o666); err != nil {
-		return fmt.Errorf("WriteFile: %v", err)
+		return errors.Newf("WriteFile: %v", err)
 	}
 
 	if message == "" {
 		message = "Update page '" + title + "'"
 	}
 	if err = git.Add(localPath, git.AddOptions{All: true}); err != nil {
-		return fmt.Errorf("add all changes: %v", err)
+		return errors.Newf("add all changes: %v", err)
 	}
 
 	err = git.CreateCommit(
@@ -148,9 +148,9 @@ func (r *Repository) updateWikiPage(doer *User, oldTitle, title, content, messag
 		message,
 	)
 	if err != nil {
-		return fmt.Errorf("commit changes: %v", err)
+		return errors.Newf("commit changes: %v", err)
 	} else if err = git.Push(localPath, "origin", WikiBranch(localPath)); err != nil {
-		return fmt.Errorf("push: %v", err)
+		return errors.Newf("push: %v", err)
 	}
 
 	return nil
@@ -170,9 +170,9 @@ func (r *Repository) DeleteWikiPage(doer *User, title string) (err error) {
 
 	localPath := r.LocalWikiPath()
 	if err = discardLocalWikiChanges(localPath); err != nil {
-		return fmt.Errorf("discardLocalWikiChanges: %v", err)
+		return errors.Newf("discardLocalWikiChanges: %v", err)
 	} else if err = r.UpdateLocalWiki(); err != nil {
-		return fmt.Errorf("UpdateLocalWiki: %v", err)
+		return errors.Newf("UpdateLocalWiki: %v", err)
 	}
 
 	title = ToWikiPageName(title)
@@ -182,7 +182,7 @@ func (r *Repository) DeleteWikiPage(doer *User, title string) (err error) {
 	message := "Delete page '" + title + "'"
 
 	if err = git.Add(localPath, git.AddOptions{All: true}); err != nil {
-		return fmt.Errorf("add all changes: %v", err)
+		return errors.Newf("add all changes: %v", err)
 	}
 
 	err = git.CreateCommit(
@@ -195,9 +195,9 @@ func (r *Repository) DeleteWikiPage(doer *User, title string) (err error) {
 		message,
 	)
 	if err != nil {
-		return fmt.Errorf("commit changes: %v", err)
+		return errors.Newf("commit changes: %v", err)
 	} else if err = git.Push(localPath, "origin", WikiBranch(localPath)); err != nil {
-		return fmt.Errorf("push: %v", err)
+		return errors.Newf("push: %v", err)
 	}
 
 	return nil