Use db.WithTx/WithTx2 instead of TxContext when possible (#35130)

models/repo/language_stats.go

@@ -141,101 +141,90 @@ func GetTopLanguageStats(ctx context.Context, repo *Repository, limit int) (Lang
 
 // UpdateLanguageStats updates the language statistics for repository
 func UpdateLanguageStats(ctx context.Context, repo *Repository, commitID string, stats map[string]int64) error {
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return err
-	}
-	defer committer.Close()
-	sess := db.GetEngine(ctx)
+	return db.WithTx(ctx, func(ctx context.Context) error {
+		sess := db.GetEngine(ctx)
 
-	oldstats, err := GetLanguageStats(ctx, repo)
-	if err != nil {
-		return err
-	}
-	var topLang string
-	var s int64
-	for lang, size := range stats {
-		if size > s {
-			s = size
-			topLang = lang
+		oldstats, err := GetLanguageStats(ctx, repo)
+		if err != nil {
+			return err
 		}
-	}
-
-	for lang, size := range stats {
-		upd := false
-		for _, s := range oldstats {
-			// Update already existing language
-			if strings.EqualFold(s.Language, lang) {
-				s.CommitID = commitID
-				s.IsPrimary = lang == topLang
-				s.Size = size
-				if _, err := sess.ID(s.ID).Cols("`commit_id`", "`size`", "`is_primary`").Update(s); err != nil {
-					return err
-				}
-				upd = true
-				break
+		var topLang string
+		var s int64
+		for lang, size := range stats {
+			if size > s {
+				s = size
+				topLang = lang
 			}
 		}
-		// Insert new language
-		if !upd {
-			if err := db.Insert(ctx, &LanguageStat{
-				RepoID:    repo.ID,
-				CommitID:  commitID,
-				IsPrimary: lang == topLang,
-				Language:  lang,
-				Size:      size,
-			}); err != nil {
+
+		for lang, size := range stats {
+			upd := false
+			for _, s := range oldstats {
+				// Update already existing language
+				if strings.EqualFold(s.Language, lang) {
+					s.CommitID = commitID
+					s.IsPrimary = lang == topLang
+					s.Size = size
+					if _, err := sess.ID(s.ID).Cols("`commit_id`", "`size`", "`is_primary`").Update(s); err != nil {
+						return err
+					}
+					upd = true
+					break
+				}
+			}
+			// Insert new language
+			if !upd {
+				if err := db.Insert(ctx, &LanguageStat{
+					RepoID:    repo.ID,
+					CommitID:  commitID,
+					IsPrimary: lang == topLang,
+					Language:  lang,
+					Size:      size,
+				}); err != nil {
+					return err
+				}
+			}
+		}
+		// Delete old languages
+		statsToDelete := make([]int64, 0, len(oldstats))
+		for _, s := range oldstats {
+			if s.CommitID != commitID {
+				statsToDelete = append(statsToDelete, s.ID)
+			}
+		}
+		if len(statsToDelete) > 0 {
+			if _, err := sess.In("`id`", statsToDelete).Delete(&LanguageStat{}); err != nil {
 				return err
 			}
 		}
-	}
-	// Delete old languages
-	statsToDelete := make([]int64, 0, len(oldstats))
-	for _, s := range oldstats {
-		if s.CommitID != commitID {
-			statsToDelete = append(statsToDelete, s.ID)
-		}
-	}
-	if len(statsToDelete) > 0 {
-		if _, err := sess.In("`id`", statsToDelete).Delete(&LanguageStat{}); err != nil {
-			return err
-		}
-	}
 
-	// Update indexer status
-	if err = UpdateIndexerStatus(ctx, repo, RepoIndexerTypeStats, commitID); err != nil {
-		return err
-	}
-
-	return committer.Commit()
+		// Update indexer status
+		return UpdateIndexerStatus(ctx, repo, RepoIndexerTypeStats, commitID)
+	})
 }
 
 // CopyLanguageStat Copy originalRepo language stat information to destRepo (use for forked repo)
 func CopyLanguageStat(ctx context.Context, originalRepo, destRepo *Repository) error {
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return err
-	}
-	defer committer.Close()
-
-	RepoLang := make(LanguageStatList, 0, 6)
-	if err := db.GetEngine(ctx).Where("`repo_id` = ?", originalRepo.ID).Desc("`size`").Find(&RepoLang); err != nil {
-		return err
-	}
-	if len(RepoLang) > 0 {
-		for i := range RepoLang {
-			RepoLang[i].ID = 0
-			RepoLang[i].RepoID = destRepo.ID
-			RepoLang[i].CreatedUnix = timeutil.TimeStampNow()
-		}
-		// update destRepo's indexer status
-		tmpCommitID := RepoLang[0].CommitID
-		if err := UpdateIndexerStatus(ctx, destRepo, RepoIndexerTypeStats, tmpCommitID); err != nil {
+	return db.WithTx(ctx, func(ctx context.Context) error {
+		RepoLang := make(LanguageStatList, 0, 6)
+		if err := db.GetEngine(ctx).Where("`repo_id` = ?", originalRepo.ID).Desc("`size`").Find(&RepoLang); err != nil {
 			return err
 		}
-		if err := db.Insert(ctx, &RepoLang); err != nil {
-			return err
+		if len(RepoLang) > 0 {
+			for i := range RepoLang {
+				RepoLang[i].ID = 0
+				RepoLang[i].RepoID = destRepo.ID
+				RepoLang[i].CreatedUnix = timeutil.TimeStampNow()
+			}
+			// update destRepo's indexer status
+			tmpCommitID := RepoLang[0].CommitID
+			if err := UpdateIndexerStatus(ctx, destRepo, RepoIndexerTypeStats, tmpCommitID); err != nil {
+				return err
+			}
+			if err := db.Insert(ctx, &RepoLang); err != nil {
+				return err
+			}
 		}
-	}
-	return committer.Commit()
+		return nil
+	})
 }

models/repo/release.go

@@ -472,30 +472,24 @@ func (r *Release) GetExternalID() int64 { return r.OriginalAuthorID }
 
 // InsertReleases migrates release
 func InsertReleases(ctx context.Context, rels ...*Release) error {
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return err
-	}
-	defer committer.Close()
-	sess := db.GetEngine(ctx)
-
-	for _, rel := range rels {
-		if _, err := sess.NoAutoTime().Insert(rel); err != nil {
-			return err
-		}
-
-		if len(rel.Attachments) > 0 {
-			for i := range rel.Attachments {
-				rel.Attachments[i].ReleaseID = rel.ID
-			}
-
-			if _, err := sess.NoAutoTime().Insert(rel.Attachments); err != nil {
+	return db.WithTx(ctx, func(ctx context.Context) error {
+		for _, rel := range rels {
+			if _, err := db.GetEngine(ctx).NoAutoTime().Insert(rel); err != nil {
 				return err
 			}
-		}
-	}
 
-	return committer.Commit()
+			if len(rel.Attachments) > 0 {
+				for i := range rel.Attachments {
+					rel.Attachments[i].ReleaseID = rel.ID
+				}
+
+				if _, err := db.GetEngine(ctx).NoAutoTime().Insert(rel.Attachments); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	})
 }
 
 func FindTagsByCommitIDs(ctx context.Context, repoID int64, commitIDs ...string) (map[string][]*Release, error) {

models/repo/star.go

@@ -25,48 +25,45 @@ func init() {
 
 // StarRepo or unstar repository.
 func StarRepo(ctx context.Context, doer *user_model.User, repo *Repository, star bool) error {
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return err
-	}
-	defer committer.Close()
-	staring := IsStaring(ctx, doer.ID, repo.ID)
+	return db.WithTx(ctx, func(ctx context.Context) error {
+		staring := IsStaring(ctx, doer.ID, repo.ID)
 
-	if star {
-		if user_model.IsUserBlockedBy(ctx, doer, repo.OwnerID) {
-			return user_model.ErrBlockedUser
+		if star {
+			if user_model.IsUserBlockedBy(ctx, doer, repo.OwnerID) {
+				return user_model.ErrBlockedUser
+			}
+
+			if staring {
+				return nil
+			}
+
+			if err := db.Insert(ctx, &Star{UID: doer.ID, RepoID: repo.ID}); err != nil {
+				return err
+			}
+			if _, err := db.Exec(ctx, "UPDATE `repository` SET num_stars = num_stars + 1 WHERE id = ?", repo.ID); err != nil {
+				return err
+			}
+			if _, err := db.Exec(ctx, "UPDATE `user` SET num_stars = num_stars + 1 WHERE id = ?", doer.ID); err != nil {
+				return err
+			}
+		} else {
+			if !staring {
+				return nil
+			}
+
+			if _, err := db.DeleteByBean(ctx, &Star{UID: doer.ID, RepoID: repo.ID}); err != nil {
+				return err
+			}
+			if _, err := db.Exec(ctx, "UPDATE `repository` SET num_stars = num_stars - 1 WHERE id = ?", repo.ID); err != nil {
+				return err
+			}
+			if _, err := db.Exec(ctx, "UPDATE `user` SET num_stars = num_stars - 1 WHERE id = ?", doer.ID); err != nil {
+				return err
+			}
 		}
 
-		if staring {
-			return nil
-		}
-
-		if err := db.Insert(ctx, &Star{UID: doer.ID, RepoID: repo.ID}); err != nil {
-			return err
-		}
-		if _, err := db.Exec(ctx, "UPDATE `repository` SET num_stars = num_stars + 1 WHERE id = ?", repo.ID); err != nil {
-			return err
-		}
-		if _, err := db.Exec(ctx, "UPDATE `user` SET num_stars = num_stars + 1 WHERE id = ?", doer.ID); err != nil {
-			return err
-		}
-	} else {
-		if !staring {
-			return nil
-		}
-
-		if _, err := db.DeleteByBean(ctx, &Star{UID: doer.ID, RepoID: repo.ID}); err != nil {
-			return err
-		}
-		if _, err := db.Exec(ctx, "UPDATE `repository` SET num_stars = num_stars - 1 WHERE id = ?", repo.ID); err != nil {
-			return err
-		}
-		if _, err := db.Exec(ctx, "UPDATE `user` SET num_stars = num_stars - 1 WHERE id = ?", doer.ID); err != nil {
-			return err
-		}
-	}
-
-	return committer.Commit()
+		return nil
+	})
 }
 
 // IsStaring checks if user has starred given repository.

models/repo/topic.go

@@ -227,32 +227,26 @@ func GetRepoTopicByName(ctx context.Context, repoID int64, topicName string) (*T
 
 // AddTopic adds a topic name to a repository (if it does not already have it)
 func AddTopic(ctx context.Context, repoID int64, topicName string) (*Topic, error) {
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return nil, err
-	}
-	defer committer.Close()
-	sess := db.GetEngine(ctx)
+	return db.WithTx2(ctx, func(ctx context.Context) (*Topic, error) {
+		topic, err := GetRepoTopicByName(ctx, repoID, topicName)
+		if err != nil {
+			return nil, err
+		}
+		if topic != nil {
+			// Repo already have topic
+			return topic, nil
+		}
 
-	topic, err := GetRepoTopicByName(ctx, repoID, topicName)
-	if err != nil {
-		return nil, err
-	}
-	if topic != nil {
-		// Repo already have topic
+		topic, err = addTopicByNameToRepo(ctx, repoID, topicName)
+		if err != nil {
+			return nil, err
+		}
+
+		if err = syncTopicsInRepository(ctx, repoID); err != nil {
+			return nil, err
+		}
 		return topic, nil
-	}
-
-	topic, err = addTopicByNameToRepo(ctx, repoID, topicName)
-	if err != nil {
-		return nil, err
-	}
-
-	if err = syncTopicsInRepository(sess, repoID); err != nil {
-		return nil, err
-	}
-
-	return topic, committer.Commit()
+	})
 }
 
 // DeleteTopic removes a topic name from a repository (if it has it)
@@ -266,14 +260,15 @@ func DeleteTopic(ctx context.Context, repoID int64, topicName string) (*Topic, e
 		return nil, nil
 	}
 
-	err = removeTopicFromRepo(ctx, repoID, topic)
-	if err != nil {
-		return nil, err
-	}
-
-	err = syncTopicsInRepository(db.GetEngine(ctx), repoID)
-
-	return topic, err
+	return db.WithTx2(ctx, func(ctx context.Context) (*Topic, error) {
+		if err = removeTopicFromRepo(ctx, repoID, topic); err != nil {
+			return nil, err
+		}
+		if err = syncTopicsInRepository(ctx, repoID); err != nil {
+			return nil, err
+		}
+		return topic, nil
+	})
 }
 
 // SaveTopics save topics to a repository
@@ -285,64 +280,55 @@ func SaveTopics(ctx context.Context, repoID int64, topicNames ...string) error {
 		return err
 	}
 
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return err
-	}
-	defer committer.Close()
-	sess := db.GetEngine(ctx)
-
-	var addedTopicNames []string
-	for _, topicName := range topicNames {
-		if strings.TrimSpace(topicName) == "" {
-			continue
-		}
-
-		var found bool
-		for _, t := range topics {
-			if strings.EqualFold(topicName, t.Name) {
-				found = true
-				break
-			}
-		}
-		if !found {
-			addedTopicNames = append(addedTopicNames, topicName)
-		}
-	}
-
-	var removeTopics []*Topic
-	for _, t := range topics {
-		var found bool
+	return db.WithTx(ctx, func(ctx context.Context) error {
+		var addedTopicNames []string
 		for _, topicName := range topicNames {
-			if strings.EqualFold(topicName, t.Name) {
-				found = true
-				break
+			if strings.TrimSpace(topicName) == "" {
+				continue
+			}
+
+			var found bool
+			for _, t := range topics {
+				if strings.EqualFold(topicName, t.Name) {
+					found = true
+					break
+				}
+			}
+			if !found {
+				addedTopicNames = append(addedTopicNames, topicName)
 			}
 		}
-		if !found {
-			removeTopics = append(removeTopics, t)
+
+		var removeTopics []*Topic
+		for _, t := range topics {
+			var found bool
+			for _, topicName := range topicNames {
+				if strings.EqualFold(topicName, t.Name) {
+					found = true
+					break
+				}
+			}
+			if !found {
+				removeTopics = append(removeTopics, t)
+			}
 		}
-	}
 
-	for _, topicName := range addedTopicNames {
-		_, err := addTopicByNameToRepo(ctx, repoID, topicName)
-		if err != nil {
-			return err
+		for _, topicName := range addedTopicNames {
+			_, err := addTopicByNameToRepo(ctx, repoID, topicName)
+			if err != nil {
+				return err
+			}
 		}
-	}
 
-	for _, topic := range removeTopics {
-		err := removeTopicFromRepo(ctx, repoID, topic)
-		if err != nil {
-			return err
+		for _, topic := range removeTopics {
+			err := removeTopicFromRepo(ctx, repoID, topic)
+			if err != nil {
+				return err
+			}
 		}
-	}
 
-	if err := syncTopicsInRepository(sess, repoID); err != nil {
-		return err
-	}
-
-	return committer.Commit()
+		return syncTopicsInRepository(ctx, repoID)
+	})
 }
 
 // GenerateTopics generates topics from a template repository
@@ -353,19 +339,19 @@ func GenerateTopics(ctx context.Context, templateRepo, generateRepo *Repository)
 		}
 	}
 
-	return syncTopicsInRepository(db.GetEngine(ctx), generateRepo.ID)
+	return syncTopicsInRepository(ctx, generateRepo.ID)
 }
 
 // syncTopicsInRepository makes sure topics in the topics table are copied into the topics field of the repository
-func syncTopicsInRepository(sess db.Engine, repoID int64) error {
+func syncTopicsInRepository(ctx context.Context, repoID int64) error {
 	topicNames := make([]string, 0, 25)
-	if err := sess.Table("topic").Cols("name").
+	if err := db.GetEngine(ctx).Table("topic").Cols("name").
 		Join("INNER", "repo_topic", "repo_topic.topic_id = topic.id").
 		Where("repo_topic.repo_id = ?", repoID).Asc("topic.name").Find(&topicNames); err != nil {
 		return err
 	}
 
-	if _, err := sess.ID(repoID).Cols("topics").Update(&Repository{
+	if _, err := db.GetEngine(ctx).ID(repoID).Cols("topics").Update(&Repository{
 		Topics: topicNames,
 	}); err != nil {
 		return err

models/repo/update.go

@@ -19,11 +19,6 @@ func UpdateRepositoryOwnerNames(ctx context.Context, ownerID int64, ownerName st
 	if ownerID == 0 {
 		return nil
 	}
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return err
-	}
-	defer committer.Close()
 
 	if _, err := db.GetEngine(ctx).Where("owner_id = ?", ownerID).Cols("owner_name").NoAutoTime().Update(&Repository{
 		OwnerName: ownerName,
@@ -31,7 +26,7 @@ func UpdateRepositoryOwnerNames(ctx context.Context, ownerID int64, ownerName st
 		return err
 	}
 
-	return committer.Commit()
+	return nil
 }
 
 // UpdateRepositoryUpdatedTime updates a repository's updated time

models/repo/upload.go

@@ -117,12 +117,6 @@ func DeleteUploads(ctx context.Context, uploads ...*Upload) (err error) {
 		return nil
 	}
 
-	ctx, committer, err := db.TxContext(ctx)
-	if err != nil {
-		return err
-	}
-	defer committer.Close()
-
 	ids := make([]int64, len(uploads))
 	for i := range uploads {
 		ids[i] = uploads[i].ID
@@ -131,10 +125,6 @@ func DeleteUploads(ctx context.Context, uploads ...*Upload) (err error) {
 		return fmt.Errorf("delete uploads: %w", err)
 	}
 
-	if err = committer.Commit(); err != nil {
-		return err
-	}
-
 	for _, upload := range uploads {
 		localPath := upload.LocalPath()
 		isFile, err := util.IsFile(localPath)