loading up the forgejo repo on tangled to test page performance
Move user functions into user.go (#17659)
* Move user functions into user.go
* Fix test
authored by
Lunny Xiao
and committed by
GitHub
3c3855a0
6874fe90
+101
-72
+16
-27
models/admin.go
models/admin/notice.go
+16
-27
models/admin.go
models/admin/notice.go
···
1
-
// Copyright 2014 The Gogs Authors. All rights reserved.
2
-
// Copyright 2020 The Gitea Authors. All rights reserved.
1
+
// Copyright 2021 The Gitea Authors. All rights reserved.
3
2
// Use of this source code is governed by a MIT-style
4
3
// license that can be found in the LICENSE file.
5
4
6
-
package models
5
+
package admin
7
6
8
7
import (
8
+
"context"
9
9
"fmt"
10
10
11
11
"code.gitea.io/gitea/models/db"
···
44
44
45
45
// CreateNotice creates new system notice.
46
46
func CreateNotice(tp NoticeType, desc string, args ...interface{}) error {
47
-
return createNotice(db.GetEngine(db.DefaultContext), tp, desc, args...)
47
+
return CreateNoticeCtx(db.DefaultContext, tp, desc, args...)
48
48
}
49
49
50
-
func createNotice(e db.Engine, tp NoticeType, desc string, args ...interface{}) error {
50
+
// CreateNoticeCtx creates new system notice.
51
+
func CreateNoticeCtx(ctx context.Context, tp NoticeType, desc string, args ...interface{}) error {
51
52
if len(args) > 0 {
52
53
desc = fmt.Sprintf(desc, args...)
53
54
}
···
55
56
Type: tp,
56
57
Description: desc,
57
58
}
58
-
_, err := e.Insert(n)
59
-
return err
59
+
return db.Insert(ctx, n)
60
60
}
61
61
62
62
// CreateRepositoryNotice creates new system notice with type NoticeRepository.
63
63
func CreateRepositoryNotice(desc string, args ...interface{}) error {
64
-
return createNotice(db.GetEngine(db.DefaultContext), NoticeRepository, desc, args...)
64
+
return CreateNoticeCtx(db.DefaultContext, NoticeRepository, desc, args...)
65
65
}
66
66
67
67
// RemoveAllWithNotice removes all directories in given path and
68
68
// creates a system notice when error occurs.
69
69
func RemoveAllWithNotice(title, path string) {
70
-
removeAllWithNotice(db.GetEngine(db.DefaultContext), title, path)
70
+
RemoveAllWithNoticeCtx(db.DefaultContext, title, path)
71
71
}
72
72
73
73
// RemoveStorageWithNotice removes a file from the storage and
74
74
// creates a system notice when error occurs.
75
75
func RemoveStorageWithNotice(bucket storage.ObjectStorage, title, path string) {
76
-
removeStorageWithNotice(db.GetEngine(db.DefaultContext), bucket, title, path)
76
+
removeStorageWithNotice(db.DefaultContext, bucket, title, path)
77
77
}
78
78
79
-
func removeStorageWithNotice(e db.Engine, bucket storage.ObjectStorage, title, path string) {
79
+
func removeStorageWithNotice(ctx context.Context, bucket storage.ObjectStorage, title, path string) {
80
80
if err := bucket.Delete(path); err != nil {
81
81
desc := fmt.Sprintf("%s [%s]: %v", title, path, err)
82
82
log.Warn(title+" [%s]: %v", path, err)
83
-
if err = createNotice(e, NoticeRepository, desc); err != nil {
83
+
if err = CreateNoticeCtx(ctx, NoticeRepository, desc); err != nil {
84
84
log.Error("CreateRepositoryNotice: %v", err)
85
85
}
86
86
}
87
87
}
88
88
89
-
func removeAllWithNotice(e db.Engine, title, path string) {
89
+
// RemoveAllWithNoticeCtx removes all directories in given path and
90
+
// creates a system notice when error occurs.
91
+
func RemoveAllWithNoticeCtx(ctx context.Context, title, path string) {
90
92
if err := util.RemoveAll(path); err != nil {
91
93
desc := fmt.Sprintf("%s [%s]: %v", title, path, err)
92
94
log.Warn(title+" [%s]: %v", path, err)
93
-
if err = createNotice(e, NoticeRepository, desc); err != nil {
95
+
if err = CreateNoticeCtx(ctx, NoticeRepository, desc); err != nil {
94
96
log.Error("CreateRepositoryNotice: %v", err)
95
97
}
96
98
}
···
142
144
Delete(new(Notice))
143
145
return err
144
146
}
145
-
146
-
// GetAdminUser returns the first administrator
147
-
func GetAdminUser() (*User, error) {
148
-
var admin User
149
-
has, err := db.GetEngine(db.DefaultContext).Where("is_admin=?", true).Get(&admin)
150
-
if err != nil {
151
-
return nil, err
152
-
} else if !has {
153
-
return nil, ErrUserNotExist{}
154
-
}
155
-
156
-
return &admin, nil
157
-
}
+18
models/admin/main_test.go
+18
models/admin/main_test.go
···
1
+
// Copyright 2020 The Gitea Authors. All rights reserved.
2
+
// Use of this source code is governed by a MIT-style
3
+
// license that can be found in the LICENSE file.
4
+
5
+
package admin
6
+
7
+
import (
8
+
"path/filepath"
9
+
"testing"
10
+
11
+
"code.gitea.io/gitea/models/unittest"
12
+
)
13
+
14
+
func TestMain(m *testing.M) {
15
+
unittest.MainTest(m, filepath.Join("..", ".."),
16
+
"notice.yml",
17
+
)
18
+
}
+1
-1
models/admin_test.go
models/admin/notice_test.go
+1
-1
models/admin_test.go
models/admin/notice_test.go
+2
-1
models/consistency.go
+2
-1
models/consistency.go
···
5
5
package models
6
6
7
7
import (
8
+
admin_model "code.gitea.io/gitea/models/admin"
8
9
"code.gitea.io/gitea/models/db"
9
10
10
11
"xorm.io/builder"
···
127
128
128
129
// Remove issue attachment files.
129
130
for i := range attachmentPaths {
130
-
removeAllWithNotice(db.GetEngine(db.DefaultContext), "Delete issue attachment", attachmentPaths[i])
131
+
admin_model.RemoveAllWithNoticeCtx(db.DefaultContext, "Delete issue attachment", attachmentPaths[i])
131
132
}
132
133
return nil
133
134
}
+9
-8
models/repo.go
+9
-8
models/repo.go
···
23
23
24
24
_ "image/jpeg" // Needed for jpeg support
25
25
26
+
admin_model "code.gitea.io/gitea/models/admin"
26
27
"code.gitea.io/gitea/models/db"
27
28
"code.gitea.io/gitea/models/unit"
28
29
"code.gitea.io/gitea/models/webhook"
···
133
134
loadRepoConfig()
134
135
unit.LoadUnitConfig()
135
136
136
-
RemoveAllWithNotice("Clean up repository temporary data", filepath.Join(setting.AppDataPath, "tmp"))
137
+
admin_model.RemoveAllWithNotice("Clean up repository temporary data", filepath.Join(setting.AppDataPath, "tmp"))
137
138
}
138
139
139
140
// RepositoryStatus defines the status of repository
···
1648
1649
1649
1650
// Remove repository files.
1650
1651
repoPath := repo.RepoPath()
1651
-
removeAllWithNotice(db.GetEngine(db.DefaultContext), "Delete repository files", repoPath)
1652
+
admin_model.RemoveAllWithNotice("Delete repository files", repoPath)
1652
1653
1653
1654
// Remove wiki files
1654
1655
if repo.HasWiki() {
1655
-
removeAllWithNotice(db.GetEngine(db.DefaultContext), "Delete repository wiki", repo.WikiPath())
1656
+
admin_model.RemoveAllWithNotice("Delete repository wiki", repo.WikiPath())
1656
1657
}
1657
1658
1658
1659
// Remove archives
1659
1660
for i := range archivePaths {
1660
-
removeStorageWithNotice(db.GetEngine(db.DefaultContext), storage.RepoArchives, "Delete repo archive file", archivePaths[i])
1661
+
admin_model.RemoveStorageWithNotice(storage.RepoArchives, "Delete repo archive file", archivePaths[i])
1661
1662
}
1662
1663
1663
1664
// Remove lfs objects
1664
1665
for i := range lfsPaths {
1665
-
removeStorageWithNotice(db.GetEngine(db.DefaultContext), storage.LFS, "Delete orphaned LFS file", lfsPaths[i])
1666
+
admin_model.RemoveStorageWithNotice(storage.LFS, "Delete orphaned LFS file", lfsPaths[i])
1666
1667
}
1667
1668
1668
1669
// Remove issue attachment files.
1669
1670
for i := range attachmentPaths {
1670
-
RemoveStorageWithNotice(storage.Attachments, "Delete issue attachment", attachmentPaths[i])
1671
+
admin_model.RemoveStorageWithNotice(storage.Attachments, "Delete issue attachment", attachmentPaths[i])
1671
1672
}
1672
1673
1673
1674
// Remove release attachment files.
1674
1675
for i := range releaseAttachments {
1675
-
RemoveStorageWithNotice(storage.Attachments, "Delete release attachment", releaseAttachments[i])
1676
+
admin_model.RemoveStorageWithNotice(storage.Attachments, "Delete release attachment", releaseAttachments[i])
1676
1677
}
1677
1678
1678
1679
// Remove attachment with no issue_id and release_id.
1679
1680
for i := range newAttachmentPaths {
1680
-
RemoveStorageWithNotice(storage.Attachments, "Delete issue attachment", attachmentPaths[i])
1681
+
admin_model.RemoveStorageWithNotice(storage.Attachments, "Delete issue attachment", attachmentPaths[i])
1681
1682
}
1682
1683
1683
1684
if len(repo.Avatar) > 0 {
+23
-8
models/user.go
+23
-8
models/user.go
···
22
22
23
23
_ "image/jpeg" // Needed for jpeg support
24
24
25
+
admin_model "code.gitea.io/gitea/models/admin"
25
26
"code.gitea.io/gitea/models/db"
26
27
"code.gitea.io/gitea/models/login"
27
28
"code.gitea.io/gitea/models/unit"
···
1148
1149
return nil
1149
1150
}
1150
1151
1151
-
func deleteUser(e db.Engine, u *User) error {
1152
+
func deleteUser(ctx context.Context, u *User) error {
1153
+
e := db.GetEngine(ctx)
1152
1154
// Note: A user owns any repository or belongs to any organization
1153
1155
// cannot perform delete operation.
1154
1156
···
1304
1306
path := UserPath(u.Name)
1305
1307
if err = util.RemoveAll(path); err != nil {
1306
1308
err = fmt.Errorf("Failed to RemoveAll %s: %v", path, err)
1307
-
_ = createNotice(e, NoticeTask, fmt.Sprintf("delete user '%s': %v", u.Name, err))
1309
+
_ = admin_model.CreateNoticeCtx(ctx, admin_model.NoticeTask, fmt.Sprintf("delete user '%s': %v", u.Name, err))
1308
1310
return err
1309
1311
}
1310
1312
···
1312
1314
avatarPath := u.CustomAvatarRelativePath()
1313
1315
if err = storage.Avatars.Delete(avatarPath); err != nil {
1314
1316
err = fmt.Errorf("Failed to remove %s: %v", avatarPath, err)
1315
-
_ = createNotice(e, NoticeTask, fmt.Sprintf("delete user '%s': %v", u.Name, err))
1317
+
_ = admin_model.CreateNoticeCtx(ctx, admin_model.NoticeTask, fmt.Sprintf("delete user '%s': %v", u.Name, err))
1316
1318
return err
1317
1319
}
1318
1320
}
···
1328
1330
return fmt.Errorf("%s is an organization not a user", u.Name)
1329
1331
}
1330
1332
1331
-
sess := db.NewSession(db.DefaultContext)
1332
-
defer sess.Close()
1333
-
if err = sess.Begin(); err != nil {
1333
+
ctx, committer, err := db.TxContext()
1334
+
if err != nil {
1334
1335
return err
1335
1336
}
1337
+
defer committer.Close()
1336
1338
1337
-
if err = deleteUser(sess, u); err != nil {
1339
+
if err = deleteUser(ctx, u); err != nil {
1338
1340
// Note: don't wrapper error here.
1339
1341
return err
1340
1342
}
1341
1343
1342
-
return sess.Commit()
1344
+
return committer.Commit()
1343
1345
}
1344
1346
1345
1347
// DeleteInactiveUsers deletes all inactive users and email addresses.
···
1825
1827
1826
1828
return nil, ErrUserNotExist{0, uri, 0}
1827
1829
}
1830
+
1831
+
// GetAdminUser returns the first administrator
1832
+
func GetAdminUser() (*User, error) {
1833
+
var admin User
1834
+
has, err := db.GetEngine(db.DefaultContext).Where("is_admin=?", true).Get(&admin)
1835
+
if err != nil {
1836
+
return nil, err
1837
+
} else if !has {
1838
+
return nil, ErrUserNotExist{}
1839
+
}
1840
+
1841
+
return &admin, nil
1842
+
}
+7
-6
modules/repository/check.go
+7
-6
modules/repository/check.go
···
11
11
"time"
12
12
13
13
"code.gitea.io/gitea/models"
14
+
admin_model "code.gitea.io/gitea/models/admin"
14
15
"code.gitea.io/gitea/models/db"
15
16
"code.gitea.io/gitea/modules/git"
16
17
"code.gitea.io/gitea/modules/log"
···
38
39
repoPath := repo.RepoPath()
39
40
if err := git.Fsck(ctx, repoPath, timeout, args...); err != nil {
40
41
log.Warn("Failed to health check repository (%v): %v", repo, err)
41
-
if err = models.CreateRepositoryNotice("Failed to health check repository (%s): %v", repo.FullName(), err); err != nil {
42
+
if err = admin_model.CreateRepositoryNotice("Failed to health check repository (%s): %v", repo.FullName(), err); err != nil {
42
43
log.Error("CreateRepositoryNotice: %v", err)
43
44
}
44
45
}
···
87
88
if err != nil {
88
89
log.Error("Repository garbage collection failed for %v. Stdout: %s\nError: %v", repo, stdout, err)
89
90
desc := fmt.Sprintf("Repository garbage collection failed for %s. Stdout: %s\nError: %v", repo.RepoPath(), stdout, err)
90
-
if err = models.CreateRepositoryNotice(desc); err != nil {
91
+
if err = admin_model.CreateRepositoryNotice(desc); err != nil {
91
92
log.Error("CreateRepositoryNotice: %v", err)
92
93
}
93
94
return fmt.Errorf("Repository garbage collection failed in repo: %s: Error: %v", repo.FullName(), err)
···
97
98
if err := repo.UpdateSize(db.DefaultContext); err != nil {
98
99
log.Error("Updating size as part of garbage collection failed for %v. Stdout: %s\nError: %v", repo, stdout, err)
99
100
desc := fmt.Sprintf("Updating size as part of garbage collection failed for %s. Stdout: %s\nError: %v", repo.RepoPath(), stdout, err)
100
-
if err = models.CreateRepositoryNotice(desc); err != nil {
101
+
if err = admin_model.CreateRepositoryNotice(desc); err != nil {
101
102
log.Error("CreateRepositoryNotice: %v", err)
102
103
}
103
104
return fmt.Errorf("Updating size as part of garbage collection failed in repo: %s: Error: %v", repo.FullName(), err)
···
139
140
if strings.HasPrefix(err.Error(), "Aborted gathering missing repo") {
140
141
return nil, err
141
142
}
142
-
if err2 := models.CreateRepositoryNotice("gatherMissingRepoRecords: %v", err); err2 != nil {
143
+
if err2 := admin_model.CreateRepositoryNotice("gatherMissingRepoRecords: %v", err); err2 != nil {
143
144
log.Error("CreateRepositoryNotice: %v", err2)
144
145
}
145
146
return nil, err
···
167
168
log.Trace("Deleting %d/%d...", repo.OwnerID, repo.ID)
168
169
if err := models.DeleteRepository(doer, repo.OwnerID, repo.ID); err != nil {
169
170
log.Error("Failed to DeleteRepository %s [%d]: Error: %v", repo.FullName(), repo.ID, err)
170
-
if err2 := models.CreateRepositoryNotice("Failed to DeleteRepository %s [%d]: Error: %v", repo.FullName(), repo.ID, err); err2 != nil {
171
+
if err2 := admin_model.CreateRepositoryNotice("Failed to DeleteRepository %s [%d]: Error: %v", repo.FullName(), repo.ID, err); err2 != nil {
171
172
log.Error("CreateRepositoryNotice: %v", err)
172
173
}
173
174
}
···
195
196
log.Trace("Initializing %d/%d...", repo.OwnerID, repo.ID)
196
197
if err := git.InitRepository(repo.RepoPath(), true); err != nil {
197
198
log.Error("Unable (re)initialize repository %d at %s. Error: %v", repo.ID, repo.RepoPath(), err)
198
-
if err2 := models.CreateRepositoryNotice("InitRepository [%d]: %v", repo.ID, err); err2 != nil {
199
+
if err2 := admin_model.CreateRepositoryNotice("InitRepository [%d]: %v", repo.ID, err); err2 != nil {
199
200
log.Error("CreateRepositoryNotice: %v", err2)
200
201
}
201
202
}
+5
-5
routers/web/admin/notice.go
+5
-5
routers/web/admin/notice.go
···
9
9
"net/http"
10
10
"strconv"
11
11
12
-
"code.gitea.io/gitea/models"
12
+
admin_model "code.gitea.io/gitea/models/admin"
13
13
"code.gitea.io/gitea/modules/base"
14
14
"code.gitea.io/gitea/modules/context"
15
15
"code.gitea.io/gitea/modules/log"
···
26
26
ctx.Data["PageIsAdmin"] = true
27
27
ctx.Data["PageIsAdminNotices"] = true
28
28
29
-
total := models.CountNotices()
29
+
total := admin_model.CountNotices()
30
30
page := ctx.FormInt("page")
31
31
if page <= 1 {
32
32
page = 1
33
33
}
34
34
35
-
notices, err := models.Notices(page, setting.UI.Admin.NoticePagingNum)
35
+
notices, err := admin_model.Notices(page, setting.UI.Admin.NoticePagingNum)
36
36
if err != nil {
37
37
ctx.ServerError("Notices", err)
38
38
return
···
57
57
}
58
58
}
59
59
60
-
if err := models.DeleteNoticesByIDs(ids); err != nil {
60
+
if err := admin_model.DeleteNoticesByIDs(ids); err != nil {
61
61
ctx.Flash.Error("DeleteNoticesByIDs: " + err.Error())
62
62
ctx.Status(500)
63
63
} else {
···
68
68
69
69
// EmptyNotices delete all the notices
70
70
func EmptyNotices(ctx *context.Context) {
71
-
if err := models.DeleteNotices(0, 0); err != nil {
71
+
if err := admin_model.DeleteNotices(0, 0); err != nil {
72
72
ctx.ServerError("DeleteNotices", err)
73
73
return
74
74
}
+2
-2
routers/web/repo/middlewares.go
+2
-2
routers/web/repo/middlewares.go
···
7
7
import (
8
8
"fmt"
9
9
10
-
"code.gitea.io/gitea/models"
10
+
admin_model "code.gitea.io/gitea/models/admin"
11
11
"code.gitea.io/gitea/modules/context"
12
12
"code.gitea.io/gitea/modules/git"
13
13
)
···
23
23
24
24
if err != nil && !git.IsErrNotExist(err) {
25
25
description := fmt.Sprintf("Error while getting .editorconfig file: %v", err)
26
-
if err := models.CreateRepositoryNotice(description); err != nil {
26
+
if err := admin_model.CreateRepositoryNotice(description); err != nil {
27
27
ctx.ServerError("ErrCreatingReporitoryNotice", err)
28
28
}
29
29
return
+4
-3
services/cron/tasks.go
+4
-3
services/cron/tasks.go
···
11
11
"sync"
12
12
13
13
"code.gitea.io/gitea/models"
14
+
admin_model "code.gitea.io/gitea/models/admin"
14
15
"code.gitea.io/gitea/models/db"
15
16
"code.gitea.io/gitea/modules/graceful"
16
17
"code.gitea.io/gitea/modules/log"
···
89
90
if err := t.fun(ctx, doer, config); err != nil {
90
91
if db.IsErrCancelled(err) {
91
92
message := err.(db.ErrCancelled).Message
92
-
if err := models.CreateNotice(models.NoticeTask, config.FormatMessage(t.Name, "aborted", doer, message)); err != nil {
93
+
if err := admin_model.CreateNotice(admin_model.NoticeTask, config.FormatMessage(t.Name, "aborted", doer, message)); err != nil {
93
94
log.Error("CreateNotice: %v", err)
94
95
}
95
96
return
96
97
}
97
-
if err := models.CreateNotice(models.NoticeTask, config.FormatMessage(t.Name, "error", doer, err)); err != nil {
98
+
if err := admin_model.CreateNotice(admin_model.NoticeTask, config.FormatMessage(t.Name, "error", doer, err)); err != nil {
98
99
log.Error("CreateNotice: %v", err)
99
100
}
100
101
return
101
102
}
102
103
if config.DoNoticeOnSuccess() {
103
-
if err := models.CreateNotice(models.NoticeTask, config.FormatMessage(t.Name, "finished", doer)); err != nil {
104
+
if err := admin_model.CreateNotice(admin_model.NoticeTask, config.FormatMessage(t.Name, "finished", doer)); err != nil {
104
105
log.Error("CreateNotice: %v", err)
105
106
}
106
107
}
+4
-4
services/migrations/gitea_downloader.go
+4
-4
services/migrations/gitea_downloader.go
···
15
15
"strings"
16
16
"time"
17
17
18
-
"code.gitea.io/gitea/models"
18
+
admin_model "code.gitea.io/gitea/models/admin"
19
19
"code.gitea.io/gitea/modules/log"
20
20
base "code.gitea.io/gitea/modules/migration"
21
21
"code.gitea.io/gitea/modules/proxy"
···
417
417
reactions, err := g.getIssueReactions(issue.Index)
418
418
if err != nil {
419
419
log.Warn("Unable to load reactions during migrating issue #%d to %s/%s. Error: %v", issue.Index, g.repoOwner, g.repoName, err)
420
-
if err2 := models.CreateRepositoryNotice(
420
+
if err2 := admin_model.CreateRepositoryNotice(
421
421
fmt.Sprintf("Unable to load reactions during migrating issue #%d to %s/%s. Error: %v", issue.Index, g.repoOwner, g.repoName, err)); err2 != nil {
422
422
log.Error("create repository notice failed: ", err2)
423
423
}
···
479
479
reactions, err := g.getCommentReactions(comment.ID)
480
480
if err != nil {
481
481
log.Warn("Unable to load comment reactions during migrating issue #%d for comment %d to %s/%s. Error: %v", opts.Context.ForeignID(), comment.ID, g.repoOwner, g.repoName, err)
482
-
if err2 := models.CreateRepositoryNotice(
482
+
if err2 := admin_model.CreateRepositoryNotice(
483
483
fmt.Sprintf("Unable to load reactions during migrating issue #%d for comment %d to %s/%s. Error: %v", opts.Context.ForeignID(), comment.ID, g.repoOwner, g.repoName, err)); err2 != nil {
484
484
log.Error("create repository notice failed: ", err2)
485
485
}
···
557
557
reactions, err := g.getIssueReactions(pr.Index)
558
558
if err != nil {
559
559
log.Warn("Unable to load reactions during migrating pull #%d to %s/%s. Error: %v", pr.Index, g.repoOwner, g.repoName, err)
560
-
if err2 := models.CreateRepositoryNotice(
560
+
if err2 := admin_model.CreateRepositoryNotice(
561
561
fmt.Sprintf("Unable to load reactions during migrating pull #%d to %s/%s. Error: %v", pr.Index, g.repoOwner, g.repoName, err)); err2 != nil {
562
562
log.Error("create repository notice failed: ", err2)
563
563
}
+2
-1
services/migrations/migrate.go
+2
-1
services/migrations/migrate.go
···
14
14
"strings"
15
15
16
16
"code.gitea.io/gitea/models"
17
+
admin_model "code.gitea.io/gitea/models/admin"
17
18
"code.gitea.io/gitea/modules/log"
18
19
"code.gitea.io/gitea/modules/matchlist"
19
20
base "code.gitea.io/gitea/modules/migration"
···
122
123
if err1 := uploader.Rollback(); err1 != nil {
123
124
log.Error("rollback failed: %v", err1)
124
125
}
125
-
if err2 := models.CreateRepositoryNotice(fmt.Sprintf("Migrate repository from %s failed: %v", opts.OriginalURL, err)); err2 != nil {
126
+
if err2 := admin_model.CreateRepositoryNotice(fmt.Sprintf("Migrate repository from %s failed: %v", opts.OriginalURL, err)); err2 != nil {
126
127
log.Error("create respotiry notice failed: ", err2)
127
128
}
128
129
return nil, err
+6
-5
services/mirror/mirror_pull.go
+6
-5
services/mirror/mirror_pull.go
···
11
11
"time"
12
12
13
13
"code.gitea.io/gitea/models"
14
+
admin_model "code.gitea.io/gitea/models/admin"
14
15
"code.gitea.io/gitea/models/db"
15
16
"code.gitea.io/gitea/modules/cache"
16
17
"code.gitea.io/gitea/modules/git"
···
170
171
171
172
log.Error("Failed to prune mirror repository %s%-v references:\nStdout: %s\nStderr: %s\nErr: %v", wiki, m.Repo, stdoutMessage, stderrMessage, pruneErr)
172
173
desc := fmt.Sprintf("Failed to prune mirror repository %s'%s' references: %s", wiki, repoPath, stderrMessage)
173
-
if err := models.CreateRepositoryNotice(desc); err != nil {
174
+
if err := admin_model.CreateRepositoryNotice(desc); err != nil {
174
175
log.Error("CreateRepositoryNotice: %v", err)
175
176
}
176
177
// this if will only be reached on a successful prune so try to get the mirror again
···
239
240
if err != nil {
240
241
log.Error("Failed to update mirror repository %-v:\nStdout: %s\nStderr: %s\nErr: %v", m.Repo, stdoutMessage, stderrMessage, err)
241
242
desc := fmt.Sprintf("Failed to update mirror repository '%s': %s", repoPath, stderrMessage)
242
-
if err = models.CreateRepositoryNotice(desc); err != nil {
243
+
if err = admin_model.CreateRepositoryNotice(desc); err != nil {
243
244
log.Error("CreateRepositoryNotice: %v", err)
244
245
}
245
246
return nil, false
···
323
324
if err != nil {
324
325
log.Error("Failed to update mirror repository wiki %-v:\nStdout: %s\nStderr: %s\nErr: %v", m.Repo, stdoutMessage, stderrMessage, err)
325
326
desc := fmt.Sprintf("Failed to update mirror repository wiki '%s': %s", wikiPath, stderrMessage)
326
-
if err = models.CreateRepositoryNotice(desc); err != nil {
327
+
if err = admin_model.CreateRepositoryNotice(desc); err != nil {
327
328
log.Error("CreateRepositoryNotice: %v", err)
328
329
}
329
330
return nil, false
···
524
525
if !git.IsErrUnsupportedVersion(err) {
525
526
log.Error("Failed to update default branch of underlying git repository %-v. Error: %v", m.Repo, err)
526
527
desc := fmt.Sprintf("Failed to uupdate default branch of underlying git repository '%s': %v", m.Repo.RepoPath(), err)
527
-
if err = models.CreateRepositoryNotice(desc); err != nil {
528
+
if err = admin_model.CreateRepositoryNotice(desc); err != nil {
528
529
log.Error("CreateRepositoryNotice: %v", err)
529
530
}
530
531
return false
···
535
536
if err := models.UpdateRepositoryCols(m.Repo, "default_branch", "is_empty"); err != nil {
536
537
log.Error("Failed to update default branch of repository %-v. Error: %v", m.Repo, err)
537
538
desc := fmt.Sprintf("Failed to uupdate default branch of repository '%s': %v", m.Repo.RepoPath(), err)
538
-
if err = models.CreateRepositoryNotice(desc); err != nil {
539
+
if err = admin_model.CreateRepositoryNotice(desc); err != nil {
539
540
log.Error("CreateRepositoryNotice: %v", err)
540
541
}
541
542
return false
+2
-1
services/wiki/wiki.go
+2
-1
services/wiki/wiki.go
···
12
12
"strings"
13
13
14
14
"code.gitea.io/gitea/models"
15
+
admin_model "code.gitea.io/gitea/models/admin"
15
16
"code.gitea.io/gitea/models/unit"
16
17
"code.gitea.io/gitea/modules/git"
17
18
"code.gitea.io/gitea/modules/log"
···
374
375
return err
375
376
}
376
377
377
-
models.RemoveAllWithNotice("Delete repository wiki", repo.WikiPath())
378
+
admin_model.RemoveAllWithNotice("Delete repository wiki", repo.WikiPath())
378
379
return nil
379
380
}