loading up the forgejo repo on tangled to test page performance
Replace more db.DefaultContext (#27628)
Target #27065
authored by
Lunny Xiao
and committed by
GitHub
cddf245c
7480aacd
+99
-85
+7
-5
contrib/fixtures/fixture_generation.go
+7
-5
contrib/fixtures/fixture_generation.go
···
5
5
package main
6
6
7
7
import (
8
+
"context"
8
9
"fmt"
9
10
"os"
10
11
"path/filepath"
···
18
19
19
20
var (
20
21
generators = []struct {
21
-
gen func() (string, error)
22
+
gen func(ctx context.Context) (string, error)
22
23
name string
23
24
}{
24
25
{
···
41
42
fmt.Printf("PrepareTestDatabase: %+v\n", err)
42
43
os.Exit(1)
43
44
}
45
+
ctx := context.Background()
44
46
if len(os.Args) == 0 {
45
47
for _, r := range os.Args {
46
-
if err := generate(r); err != nil {
48
+
if err := generate(ctx, r); err != nil {
47
49
fmt.Printf("generate '%s': %+v\n", r, err)
48
50
os.Exit(1)
49
51
}
50
52
}
51
53
} else {
52
54
for _, g := range generators {
53
-
if err := generate(g.name); err != nil {
55
+
if err := generate(ctx, g.name); err != nil {
54
56
fmt.Printf("generate '%s': %+v\n", g.name, err)
55
57
os.Exit(1)
56
58
}
···
58
60
}
59
61
}
60
62
61
-
func generate(name string) error {
63
+
func generate(ctx context.Context, name string) error {
62
64
for _, g := range generators {
63
65
if g.name == name {
64
-
data, err := g.gen()
66
+
data, err := g.gen(ctx)
65
67
if err != nil {
66
68
return err
67
69
}
+6
-5
models/fixture_generation.go
+6
-5
models/fixture_generation.go
···
4
4
package models
5
5
6
6
import (
7
+
"context"
7
8
"fmt"
8
9
"strings"
9
10
···
14
15
15
16
// GetYamlFixturesAccess returns a string containing the contents
16
17
// for the access table, as recalculated using repo.RecalculateAccesses()
17
-
func GetYamlFixturesAccess() (string, error) {
18
+
func GetYamlFixturesAccess(ctx context.Context) (string, error) {
18
19
repos := make([]*repo_model.Repository, 0, 50)
19
-
if err := db.GetEngine(db.DefaultContext).Find(&repos); err != nil {
20
+
if err := db.GetEngine(ctx).Find(&repos); err != nil {
20
21
return "", err
21
22
}
22
23
23
24
for _, repo := range repos {
24
-
repo.MustOwner(db.DefaultContext)
25
-
if err := access_model.RecalculateAccesses(db.DefaultContext, repo); err != nil {
25
+
repo.MustOwner(ctx)
26
+
if err := access_model.RecalculateAccesses(ctx, repo); err != nil {
26
27
return "", err
27
28
}
28
29
}
···
30
31
var b strings.Builder
31
32
32
33
accesses := make([]*access_model.Access, 0, 200)
33
-
if err := db.GetEngine(db.DefaultContext).OrderBy("user_id, repo_id").Find(&accesses); err != nil {
34
+
if err := db.GetEngine(ctx).OrderBy("user_id, repo_id").Find(&accesses); err != nil {
34
35
return "", err
35
36
}
36
37
+5
-3
models/fixture_test.go
+5
-3
models/fixture_test.go
···
4
4
package models
5
5
6
6
import (
7
+
"context"
7
8
"os"
8
9
"path/filepath"
9
10
"testing"
10
11
12
+
"code.gitea.io/gitea/models/db"
11
13
"code.gitea.io/gitea/models/unittest"
12
14
"code.gitea.io/gitea/modules/util"
13
15
···
17
19
func TestFixtureGeneration(t *testing.T) {
18
20
assert.NoError(t, unittest.PrepareTestDatabase())
19
21
20
-
test := func(gen func() (string, error), name string) {
21
-
expected, err := gen()
22
+
test := func(ctx context.Context, gen func(ctx context.Context) (string, error), name string) {
23
+
expected, err := gen(ctx)
22
24
if !assert.NoError(t, err) {
23
25
return
24
26
}
···
31
33
assert.EqualValues(t, expected, data, "Differences detected for %s", p)
32
34
}
33
35
34
-
test(GetYamlFixturesAccess, "access")
36
+
test(db.DefaultContext, GetYamlFixturesAccess, "access")
35
37
}
+2
-2
models/org.go
+2
-2
models/org.go
···
97
97
}
98
98
99
99
// RemoveOrgUser removes user from given organization.
100
-
func RemoveOrgUser(orgID, userID int64) error {
101
-
ctx, committer, err := db.TxContext(db.DefaultContext)
100
+
func RemoveOrgUser(ctx context.Context, orgID, userID int64) error {
101
+
ctx, committer, err := db.TxContext(ctx)
102
102
if err != nil {
103
103
return err
104
104
}
+5
-4
models/org_test.go
+5
-4
models/org_test.go
···
6
6
import (
7
7
"testing"
8
8
9
+
"code.gitea.io/gitea/models/db"
9
10
"code.gitea.io/gitea/models/organization"
10
11
"code.gitea.io/gitea/models/unittest"
11
12
user_model "code.gitea.io/gitea/models/user"
···
20
21
// remove a user that is a member
21
22
unittest.AssertExistsAndLoadBean(t, &organization.OrgUser{UID: 4, OrgID: 3})
22
23
prevNumMembers := org.NumMembers
23
-
assert.NoError(t, RemoveOrgUser(org.ID, 4))
24
+
assert.NoError(t, RemoveOrgUser(db.DefaultContext, org.ID, 4))
24
25
unittest.AssertNotExistsBean(t, &organization.OrgUser{UID: 4, OrgID: 3})
25
26
org = unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 3})
26
27
assert.Equal(t, prevNumMembers-1, org.NumMembers)
···
28
29
// remove a user that is not a member
29
30
unittest.AssertNotExistsBean(t, &organization.OrgUser{UID: 5, OrgID: 3})
30
31
prevNumMembers = org.NumMembers
31
-
assert.NoError(t, RemoveOrgUser(org.ID, 5))
32
+
assert.NoError(t, RemoveOrgUser(db.DefaultContext, org.ID, 5))
32
33
unittest.AssertNotExistsBean(t, &organization.OrgUser{UID: 5, OrgID: 3})
33
34
org = unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 3})
34
35
assert.Equal(t, prevNumMembers, org.NumMembers)
···
44
45
if unittest.BeanExists(t, &organization.OrgUser{OrgID: orgID, UID: userID}) {
45
46
expectedNumMembers--
46
47
}
47
-
assert.NoError(t, RemoveOrgUser(orgID, userID))
48
+
assert.NoError(t, RemoveOrgUser(db.DefaultContext, orgID, userID))
48
49
unittest.AssertNotExistsBean(t, &organization.OrgUser{OrgID: orgID, UID: userID})
49
50
org = unittest.AssertExistsAndLoadBean(t, &user_model.User{ID: orgID})
50
51
assert.EqualValues(t, expectedNumMembers, org.NumMembers)
···
52
53
testSuccess(3, 4)
53
54
testSuccess(3, 4)
54
55
55
-
err := RemoveOrgUser(7, 5)
56
+
err := RemoveOrgUser(db.DefaultContext, 7, 5)
56
57
assert.Error(t, err)
57
58
assert.True(t, organization.IsErrLastOrgOwner(err))
58
59
unittest.AssertExistsAndLoadBean(t, &organization.OrgUser{OrgID: 7, UID: 5})
+2
-2
models/repo/repo_list.go
+2
-2
models/repo/repo_list.go
···
716
716
}
717
717
718
718
// GetUserRepositories returns a list of repositories of given user.
719
-
func GetUserRepositories(opts *SearchRepoOptions) (RepositoryList, int64, error) {
719
+
func GetUserRepositories(ctx context.Context, opts *SearchRepoOptions) (RepositoryList, int64, error) {
720
720
if len(opts.OrderBy) == 0 {
721
721
opts.OrderBy = "updated_unix DESC"
722
722
}
···
734
734
cond = cond.And(builder.In("lower_name", opts.LowerNames))
735
735
}
736
736
737
-
sess := db.GetEngine(db.DefaultContext)
737
+
sess := db.GetEngine(ctx)
738
738
739
739
count, err := sess.Where(cond).Count(new(Repository))
740
740
if err != nil {
+3
-3
models/repo/watch.go
+3
-3
models/repo/watch.go
···
107
107
}
108
108
109
109
// WatchRepoMode watch repository in specific mode.
110
-
func WatchRepoMode(userID, repoID int64, mode WatchMode) (err error) {
110
+
func WatchRepoMode(ctx context.Context, userID, repoID int64, mode WatchMode) (err error) {
111
111
var watch Watch
112
-
if watch, err = GetWatch(db.DefaultContext, userID, repoID); err != nil {
112
+
if watch, err = GetWatch(ctx, userID, repoID); err != nil {
113
113
return err
114
114
}
115
-
return watchRepoMode(db.DefaultContext, watch, mode)
115
+
return watchRepoMode(ctx, watch, mode)
116
116
}
117
117
118
118
// WatchRepo watch or unwatch repository.
+4
-4
models/repo/watch_test.go
+4
-4
models/repo/watch_test.go
···
122
122
123
123
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1}, 0)
124
124
125
-
assert.NoError(t, repo_model.WatchRepoMode(12, 1, repo_model.WatchModeAuto))
125
+
assert.NoError(t, repo_model.WatchRepoMode(db.DefaultContext, 12, 1, repo_model.WatchModeAuto))
126
126
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1}, 1)
127
127
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1, Mode: repo_model.WatchModeAuto}, 1)
128
128
129
-
assert.NoError(t, repo_model.WatchRepoMode(12, 1, repo_model.WatchModeNormal))
129
+
assert.NoError(t, repo_model.WatchRepoMode(db.DefaultContext, 12, 1, repo_model.WatchModeNormal))
130
130
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1}, 1)
131
131
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1, Mode: repo_model.WatchModeNormal}, 1)
132
132
133
-
assert.NoError(t, repo_model.WatchRepoMode(12, 1, repo_model.WatchModeDont))
133
+
assert.NoError(t, repo_model.WatchRepoMode(db.DefaultContext, 12, 1, repo_model.WatchModeDont))
134
134
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1}, 1)
135
135
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1, Mode: repo_model.WatchModeDont}, 1)
136
136
137
-
assert.NoError(t, repo_model.WatchRepoMode(12, 1, repo_model.WatchModeNone))
137
+
assert.NoError(t, repo_model.WatchRepoMode(db.DefaultContext, 12, 1, repo_model.WatchModeNone))
138
138
unittest.AssertCount(t, &repo_model.Watch{UserID: 12, RepoID: 1}, 0)
139
139
}
+4
-4
models/system/appstate.go
+4
-4
models/system/appstate.go
···
23
23
}
24
24
25
25
// SaveAppStateContent saves the app state item to database
26
-
func SaveAppStateContent(key, content string) error {
27
-
return db.WithTx(db.DefaultContext, func(ctx context.Context) error {
26
+
func SaveAppStateContent(ctx context.Context, key, content string) error {
27
+
return db.WithTx(ctx, func(ctx context.Context) error {
28
28
eng := db.GetEngine(ctx)
29
29
// try to update existing row
30
30
res, err := eng.Exec("UPDATE app_state SET revision=revision+1, content=? WHERE id=?", content, key)
···
43
43
}
44
44
45
45
// GetAppStateContent gets an app state from database
46
-
func GetAppStateContent(key string) (content string, err error) {
47
-
e := db.GetEngine(db.DefaultContext)
46
+
func GetAppStateContent(ctx context.Context, key string) (content string, err error) {
47
+
e := db.GetEngine(ctx)
48
48
appState := &AppState{ID: key}
49
49
has, err := e.Get(appState)
50
50
if err != nil {
+4
-2
modules/system/appstate.go
+4
-2
modules/system/appstate.go
···
3
3
4
4
package system
5
5
6
+
import "context"
7
+
6
8
// StateStore is the interface to get/set app state items
7
9
type StateStore interface {
8
-
Get(item StateItem) error
9
-
Set(item StateItem) error
10
+
Get(ctx context.Context, item StateItem) error
11
+
Set(ctx context.Context, item StateItem) error
10
12
}
11
13
12
14
// StateItem provides the name for a state item. the name will be used to generate filenames, etc
+6
-5
modules/system/appstate_test.go
+6
-5
modules/system/appstate_test.go
···
6
6
import (
7
7
"testing"
8
8
9
+
"code.gitea.io/gitea/models/db"
9
10
"code.gitea.io/gitea/models/unittest"
10
11
11
12
"github.com/stretchr/testify/assert"
···
40
41
as := &DBStore{}
41
42
42
43
item1 := new(testItem1)
43
-
assert.NoError(t, as.Get(item1))
44
+
assert.NoError(t, as.Get(db.DefaultContext, item1))
44
45
assert.Equal(t, "", item1.Val1)
45
46
assert.EqualValues(t, 0, item1.Val2)
46
47
47
48
item1 = new(testItem1)
48
49
item1.Val1 = "a"
49
50
item1.Val2 = 2
50
-
assert.NoError(t, as.Set(item1))
51
+
assert.NoError(t, as.Set(db.DefaultContext, item1))
51
52
52
53
item2 := new(testItem2)
53
54
item2.K = "V"
54
-
assert.NoError(t, as.Set(item2))
55
+
assert.NoError(t, as.Set(db.DefaultContext, item2))
55
56
56
57
item1 = new(testItem1)
57
-
assert.NoError(t, as.Get(item1))
58
+
assert.NoError(t, as.Get(db.DefaultContext, item1))
58
59
assert.Equal(t, "a", item1.Val1)
59
60
assert.EqualValues(t, 2, item1.Val2)
60
61
61
62
item2 = new(testItem2)
62
-
assert.NoError(t, as.Get(item2))
63
+
assert.NoError(t, as.Get(db.DefaultContext, item2))
63
64
assert.Equal(t, "V", item2.K)
64
65
}
+6
-4
modules/system/db.go
+6
-4
modules/system/db.go
···
4
4
package system
5
5
6
6
import (
7
+
"context"
8
+
7
9
"code.gitea.io/gitea/models/system"
8
10
"code.gitea.io/gitea/modules/json"
9
11
···
14
16
type DBStore struct{}
15
17
16
18
// Get reads the state item
17
-
func (f *DBStore) Get(item StateItem) error {
18
-
content, err := system.GetAppStateContent(item.Name())
19
+
func (f *DBStore) Get(ctx context.Context, item StateItem) error {
20
+
content, err := system.GetAppStateContent(ctx, item.Name())
19
21
if err != nil {
20
22
return err
21
23
}
···
26
28
}
27
29
28
30
// Set saves the state item
29
-
func (f *DBStore) Set(item StateItem) error {
31
+
func (f *DBStore) Set(ctx context.Context, item StateItem) error {
30
32
b, err := json.Marshal(item)
31
33
if err != nil {
32
34
return err
33
35
}
34
-
return system.SaveAppStateContent(item.Name(), util.BytesToReadOnlyString(b))
36
+
return system.SaveAppStateContent(ctx, item.Name(), util.BytesToReadOnlyString(b))
35
37
}
+8
-7
modules/updatechecker/update_checker.go
+8
-7
modules/updatechecker/update_checker.go
···
4
4
package updatechecker
5
5
6
6
import (
7
+
"context"
7
8
"io"
8
9
"net/http"
9
10
···
58
59
return err
59
60
}
60
61
61
-
return UpdateRemoteVersion(respData.Latest.Version)
62
+
return UpdateRemoteVersion(req.Context(), respData.Latest.Version)
62
63
}
63
64
64
65
// UpdateRemoteVersion updates the latest available version of Gitea
65
-
func UpdateRemoteVersion(version string) (err error) {
66
-
return system.AppState.Set(&CheckerState{LatestVersion: version})
66
+
func UpdateRemoteVersion(ctx context.Context, version string) (err error) {
67
+
return system.AppState.Set(ctx, &CheckerState{LatestVersion: version})
67
68
}
68
69
69
70
// GetRemoteVersion returns the current remote version (or currently installed version if fail to fetch from DB)
70
-
func GetRemoteVersion() string {
71
+
func GetRemoteVersion(ctx context.Context) string {
71
72
item := new(CheckerState)
72
-
if err := system.AppState.Get(item); err != nil {
73
+
if err := system.AppState.Get(ctx, item); err != nil {
73
74
return ""
74
75
}
75
76
return item.LatestVersion
76
77
}
77
78
78
79
// GetNeedUpdate returns true whether a newer version of Gitea is available
79
-
func GetNeedUpdate() bool {
80
+
func GetNeedUpdate(ctx context.Context) bool {
80
81
curVer, err := version.NewVersion(setting.AppVer)
81
82
if err != nil {
82
83
// return false to fail silently
83
84
return false
84
85
}
85
-
remoteVerStr := GetRemoteVersion()
86
+
remoteVerStr := GetRemoteVersion(ctx)
86
87
if remoteVerStr == "" {
87
88
// no remote version is known
88
89
return false
+1
-1
routers/api/v1/org/member.go
+1
-1
routers/api/v1/org/member.go
···
318
318
if ctx.Written() {
319
319
return
320
320
}
321
-
if err := models.RemoveOrgUser(ctx.Org.Organization.ID, member.ID); err != nil {
321
+
if err := models.RemoveOrgUser(ctx, ctx.Org.Organization.ID, member.ID); err != nil {
322
322
ctx.Error(http.StatusInternalServerError, "RemoveOrgUser", err)
323
323
}
324
324
ctx.Status(http.StatusNoContent)
+1
-1
routers/api/v1/org/org.go
+1
-1
routers/api/v1/org/org.go
···
385
385
// "404":
386
386
// "$ref": "#/responses/notFound"
387
387
388
-
if err := org.DeleteOrganization(ctx.Org.Organization); err != nil {
388
+
if err := org.DeleteOrganization(ctx, ctx.Org.Organization); err != nil {
389
389
ctx.Error(http.StatusInternalServerError, "DeleteOrganization", err)
390
390
return
391
391
}
+1
-1
routers/api/v1/user/repo.go
+1
-1
routers/api/v1/user/repo.go
···
21
21
func listUserRepos(ctx *context.APIContext, u *user_model.User, private bool) {
22
22
opts := utils.GetListOptions(ctx)
23
23
24
-
repos, count, err := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{
24
+
repos, count, err := repo_model.GetUserRepositories(ctx, &repo_model.SearchRepoOptions{
25
25
Actor: u,
26
26
Private: private,
27
27
ListOptions: opts,
+2
-2
routers/init.go
+2
-2
routers/init.go
···
72
72
73
73
func syncAppConfForGit(ctx context.Context) error {
74
74
runtimeState := new(system.RuntimeState)
75
-
if err := system.AppState.Get(runtimeState); err != nil {
75
+
if err := system.AppState.Get(ctx, runtimeState); err != nil {
76
76
return err
77
77
}
78
78
···
95
95
log.Info("re-write ssh public keys ...")
96
96
mustInitCtx(ctx, asymkey_model.RewriteAllPublicKeys)
97
97
98
-
return system.AppState.Set(runtimeState)
98
+
return system.AppState.Set(ctx, runtimeState)
99
99
}
100
100
return nil
101
101
}
+2
-2
routers/web/admin/admin.go
+2
-2
routers/web/admin/admin.go
···
127
127
func Dashboard(ctx *context.Context) {
128
128
ctx.Data["Title"] = ctx.Tr("admin.dashboard")
129
129
ctx.Data["PageIsAdminDashboard"] = true
130
-
ctx.Data["NeedUpdate"] = updatechecker.GetNeedUpdate()
131
-
ctx.Data["RemoteVersion"] = updatechecker.GetRemoteVersion()
130
+
ctx.Data["NeedUpdate"] = updatechecker.GetNeedUpdate(ctx)
131
+
ctx.Data["RemoteVersion"] = updatechecker.GetRemoteVersion(ctx)
132
132
// FIXME: update periodically
133
133
updateSystemStatus()
134
134
ctx.Data["SysStatus"] = sysStatus
+2
-2
routers/web/org/members.go
+2
-2
routers/web/org/members.go
···
104
104
ctx.Error(http.StatusNotFound)
105
105
return
106
106
}
107
-
err = models.RemoveOrgUser(org.ID, uid)
107
+
err = models.RemoveOrgUser(ctx, org.ID, uid)
108
108
if organization.IsErrLastOrgOwner(err) {
109
109
ctx.Flash.Error(ctx.Tr("form.last_org_owner"))
110
110
ctx.JSONRedirect(ctx.Org.OrgLink + "/members")
111
111
return
112
112
}
113
113
case "leave":
114
-
err = models.RemoveOrgUser(org.ID, ctx.Doer.ID)
114
+
err = models.RemoveOrgUser(ctx, org.ID, ctx.Doer.ID)
115
115
if err == nil {
116
116
ctx.Flash.Success(ctx.Tr("form.organization_leave_success", org.DisplayName()))
117
117
ctx.JSON(http.StatusOK, map[string]any{
+2
-2
routers/web/org/setting.go
+2
-2
routers/web/org/setting.go
···
124
124
125
125
// update forks visibility
126
126
if visibilityChanged {
127
-
repos, _, err := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{
127
+
repos, _, err := repo_model.GetUserRepositories(ctx, &repo_model.SearchRepoOptions{
128
128
Actor: org.AsUser(), Private: true, ListOptions: db.ListOptions{Page: 1, PageSize: org.NumRepos},
129
129
})
130
130
if err != nil {
···
180
180
return
181
181
}
182
182
183
-
if err := org_service.DeleteOrganization(ctx.Org.Organization); err != nil {
183
+
if err := org_service.DeleteOrganization(ctx, ctx.Org.Organization); err != nil {
184
184
if models.IsErrUserOwnRepos(err) {
185
185
ctx.Flash.Error(ctx.Tr("form.org_still_own_repo"))
186
186
ctx.Redirect(ctx.Org.OrgLink + "/settings/delete")
+2
-1
routers/web/user/home_test.go
+2
-1
routers/web/user/home_test.go
···
7
7
"net/http"
8
8
"testing"
9
9
10
+
"code.gitea.io/gitea/models/db"
10
11
repo_model "code.gitea.io/gitea/models/repo"
11
12
"code.gitea.io/gitea/models/unittest"
12
13
"code.gitea.io/gitea/modules/contexttest"
···
25
26
ctx.Req.Form.Set("state", "open")
26
27
27
28
// Assume: User 30 has access to two Repos with Issues, one of the Repos being archived.
28
-
repos, _, _ := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{Actor: ctx.Doer})
29
+
repos, _, _ := repo_model.GetUserRepositories(db.DefaultContext, &repo_model.SearchRepoOptions{Actor: ctx.Doer})
29
30
assert.Len(t, repos, 3)
30
31
IsArchived := make(map[int64]bool)
31
32
NumIssues := make(map[int64]int)
+1
-1
routers/web/user/package.go
+1
-1
routers/web/user/package.go
···
383
383
ctx.Data["IsPackagesPage"] = true
384
384
ctx.Data["PackageDescriptor"] = pd
385
385
386
-
repos, _, _ := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{
386
+
repos, _, _ := repo_model.GetUserRepositories(ctx, &repo_model.SearchRepoOptions{
387
387
Actor: pd.Owner,
388
388
Private: true,
389
389
})
+2
-2
routers/web/user/setting/profile.go
+2
-2
routers/web/user/setting/profile.go
···
287
287
return
288
288
}
289
289
290
-
userRepos, _, err := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{
290
+
userRepos, _, err := repo_model.GetUserRepositories(ctx, &repo_model.SearchRepoOptions{
291
291
Actor: ctxUser,
292
292
Private: true,
293
293
ListOptions: db.ListOptions{
···
312
312
ctx.Data["Dirs"] = repoNames
313
313
ctx.Data["ReposMap"] = repos
314
314
} else {
315
-
repos, count64, err := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{Actor: ctxUser, Private: true, ListOptions: opts})
315
+
repos, count64, err := repo_model.GetUserRepositories(ctx, &repo_model.SearchRepoOptions{Actor: ctxUser, Private: true, ListOptions: opts})
316
316
if err != nil {
317
317
ctx.ServerError("GetUserRepositories", err)
318
318
return
+4
-4
services/auth/session.go
+4
-4
services/auth/session.go
···
4
4
package auth
5
5
6
6
import (
7
+
"context"
7
8
"net/http"
8
9
9
-
"code.gitea.io/gitea/models/db"
10
10
user_model "code.gitea.io/gitea/models/user"
11
11
"code.gitea.io/gitea/modules/log"
12
12
)
···
29
29
// object for that uid.
30
30
// Returns nil if there is no user uid stored in the session.
31
31
func (s *Session) Verify(req *http.Request, w http.ResponseWriter, store DataStore, sess SessionStore) (*user_model.User, error) {
32
-
user := SessionUser(sess)
32
+
user := SessionUser(req.Context(), sess)
33
33
if user != nil {
34
34
return user, nil
35
35
}
···
37
37
}
38
38
39
39
// SessionUser returns the user object corresponding to the "uid" session variable.
40
-
func SessionUser(sess SessionStore) *user_model.User {
40
+
func SessionUser(ctx context.Context, sess SessionStore) *user_model.User {
41
41
if sess == nil {
42
42
return nil
43
43
}
···
55
55
}
56
56
57
57
// Get user object
58
-
user, err := user_model.GetUserByID(db.DefaultContext, id)
58
+
user, err := user_model.GetUserByID(ctx, id)
59
59
if err != nil {
60
60
if !user_model.IsErrUserNotExist(err) {
61
61
log.Error("GetUserById: %v", err)
+2
-2
services/org/org.go
+2
-2
services/org/org.go
···
19
19
)
20
20
21
21
// DeleteOrganization completely and permanently deletes everything of organization.
22
-
func DeleteOrganization(org *org_model.Organization) error {
23
-
ctx, commiter, err := db.TxContext(db.DefaultContext)
22
+
func DeleteOrganization(ctx context.Context, org *org_model.Organization) error {
23
+
ctx, commiter, err := db.TxContext(ctx)
24
24
if err != nil {
25
25
return err
26
26
}
+4
-3
services/org/org_test.go
+4
-3
services/org/org_test.go
···
7
7
"testing"
8
8
9
9
"code.gitea.io/gitea/models"
10
+
"code.gitea.io/gitea/models/db"
10
11
"code.gitea.io/gitea/models/organization"
11
12
"code.gitea.io/gitea/models/unittest"
12
13
user_model "code.gitea.io/gitea/models/user"
···
21
22
func TestDeleteOrganization(t *testing.T) {
22
23
assert.NoError(t, unittest.PrepareTestDatabase())
23
24
org := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 6})
24
-
assert.NoError(t, DeleteOrganization(org))
25
+
assert.NoError(t, DeleteOrganization(db.DefaultContext, org))
25
26
unittest.AssertNotExistsBean(t, &organization.Organization{ID: 6})
26
27
unittest.AssertNotExistsBean(t, &organization.OrgUser{OrgID: 6})
27
28
unittest.AssertNotExistsBean(t, &organization.Team{OrgID: 6})
28
29
29
30
org = unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 3})
30
-
err := DeleteOrganization(org)
31
+
err := DeleteOrganization(db.DefaultContext, org)
31
32
assert.Error(t, err)
32
33
assert.True(t, models.IsErrUserOwnRepos(err))
33
34
34
35
user := unittest.AssertExistsAndLoadBean(t, &organization.Organization{ID: 5})
35
-
assert.Error(t, DeleteOrganization(user))
36
+
assert.Error(t, DeleteOrganization(db.DefaultContext, user))
36
37
unittest.CheckConsistencyFor(t, &user_model.User{}, &organization.Team{})
37
38
}
+1
-1
services/repository/adopt.go
+1
-1
services/repository/adopt.go
···
259
259
}
260
260
return err
261
261
}
262
-
repos, _, err := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{
262
+
repos, _, err := repo_model.GetUserRepositories(ctx, &repo_model.SearchRepoOptions{
263
263
Actor: ctxUser,
264
264
Private: true,
265
265
ListOptions: db.ListOptions{
+4
-4
services/task/migrate.go
+4
-4
services/task/migrate.go
···
48
48
log.Critical("PANIC during runMigrateTask[%d] by DoerID[%d] to RepoID[%d] for OwnerID[%d]: %v\nStacktrace: %v", t.ID, t.DoerID, t.RepoID, t.OwnerID, e, log.Stack(2))
49
49
}
50
50
// fixme: Because ctx is canceled here, so the db.DefaultContext is needed.
51
+
ctx := db.DefaultContext
51
52
if err == nil {
52
-
err = admin_model.FinishMigrateTask(db.DefaultContext, t)
53
+
err = admin_model.FinishMigrateTask(ctx, t)
53
54
if err == nil {
54
-
notify_service.MigrateRepository(db.DefaultContext, t.Doer, t.Owner, t.Repo)
55
+
notify_service.MigrateRepository(ctx, t.Doer, t.Owner, t.Repo)
55
56
return
56
57
}
57
58
···
63
64
t.EndTime = timeutil.TimeStampNow()
64
65
t.Status = structs.TaskStatusFailed
65
66
t.Message = err.Error()
66
-
// fixme: Because ctx is canceled here, so the db.DefaultContext is needed.
67
-
if err := t.UpdateCols(db.DefaultContext, "status", "message", "end_time"); err != nil {
67
+
if err := t.UpdateCols(ctx, "status", "message", "end_time"); err != nil {
68
68
log.Error("Task UpdateCols failed: %v", err)
69
69
}
70
70
+2
-2
services/user/user.go
+2
-2
services/user/user.go
···
159
159
// An alternative option here would be write a DeleteAllRepositoriesForUserID function which would delete all of the repos
160
160
// but such a function would likely get out of date
161
161
for {
162
-
repos, _, err := repo_model.GetUserRepositories(&repo_model.SearchRepoOptions{
162
+
repos, _, err := repo_model.GetUserRepositories(ctx, &repo_model.SearchRepoOptions{
163
163
ListOptions: db.ListOptions{
164
164
PageSize: repo_model.RepositoryListDefaultPageSize,
165
165
Page: 1,
···
204
204
break
205
205
}
206
206
for _, org := range orgs {
207
-
if err := models.RemoveOrgUser(org.ID, u.ID); err != nil {
207
+
if err := models.RemoveOrgUser(ctx, org.ID, u.ID); err != nil {
208
208
if organization.IsErrLastOrgOwner(err) {
209
209
err = organization.DeleteOrganization(ctx, org)
210
210
}
+1
-1
services/user/user_test.go
+1
-1
services/user/user_test.go
···
41
41
orgUsers := make([]*organization.OrgUser, 0, 10)
42
42
assert.NoError(t, db.GetEngine(db.DefaultContext).Find(&orgUsers, &organization.OrgUser{UID: userID}))
43
43
for _, orgUser := range orgUsers {
44
-
if err := models.RemoveOrgUser(orgUser.OrgID, orgUser.UID); err != nil {
44
+
if err := models.RemoveOrgUser(db.DefaultContext, orgUser.OrgID, orgUser.UID); err != nil {
45
45
assert.True(t, organization.IsErrLastOrgOwner(err))
46
46
return
47
47
}
+1
-1
tests/integration/auth_ldap_test.go
+1
-1
tests/integration/auth_ldap_test.go
···
430
430
assert.True(t, isMember, "Membership should be added to the right team")
431
431
err = models.RemoveTeamMember(db.DefaultContext, team, user.ID)
432
432
assert.NoError(t, err)
433
-
err = models.RemoveOrgUser(usersOrgs[0].ID, user.ID)
433
+
err = models.RemoveOrgUser(db.DefaultContext, usersOrgs[0].ID, user.ID)
434
434
assert.NoError(t, err)
435
435
} else {
436
436
// assert members of LDAP group "cn=admin_staff" keep initial team membership since mapped team does not exist