loading up the forgejo repo on tangled to test page performance
1// Copyright 2015 The Gogs Authors. All rights reserved.
2// Copyright 2019 The Gitea Authors. All rights reserved.
3// SPDX-License-Identifier: MIT
4
5package models
6
7import (
8 "fmt"
9
10 repo_model "forgejo.org/models/repo"
11 "forgejo.org/modules/git"
12 "forgejo.org/modules/util"
13)
14
15// ErrUserOwnRepos represents a "UserOwnRepos" kind of error.
16type ErrUserOwnRepos struct {
17 UID int64
18}
19
20// IsErrUserOwnRepos checks if an error is a ErrUserOwnRepos.
21func IsErrUserOwnRepos(err error) bool {
22 _, ok := err.(ErrUserOwnRepos)
23 return ok
24}
25
26func (err ErrUserOwnRepos) Error() string {
27 return fmt.Sprintf("user still has ownership of repositories [uid: %d]", err.UID)
28}
29
30// ErrUserHasOrgs represents a "UserHasOrgs" kind of error.
31type ErrUserHasOrgs struct {
32 UID int64
33}
34
35// IsErrUserHasOrgs checks if an error is a ErrUserHasOrgs.
36func IsErrUserHasOrgs(err error) bool {
37 _, ok := err.(ErrUserHasOrgs)
38 return ok
39}
40
41func (err ErrUserHasOrgs) Error() string {
42 return fmt.Sprintf("user still has membership of organizations [uid: %d]", err.UID)
43}
44
45// ErrUserOwnPackages notifies that the user (still) owns the packages.
46type ErrUserOwnPackages struct {
47 UID int64
48}
49
50// IsErrUserOwnPackages checks if an error is an ErrUserOwnPackages.
51func IsErrUserOwnPackages(err error) bool {
52 _, ok := err.(ErrUserOwnPackages)
53 return ok
54}
55
56func (err ErrUserOwnPackages) Error() string {
57 return fmt.Sprintf("user still has ownership of packages [uid: %d]", err.UID)
58}
59
60// ErrDeleteLastAdminUser represents a "DeleteLastAdminUser" kind of error.
61type ErrDeleteLastAdminUser struct {
62 UID int64
63}
64
65// IsErrDeleteLastAdminUser checks if an error is a ErrDeleteLastAdminUser.
66func IsErrDeleteLastAdminUser(err error) bool {
67 _, ok := err.(ErrDeleteLastAdminUser)
68 return ok
69}
70
71func (err ErrDeleteLastAdminUser) Error() string {
72 return fmt.Sprintf("can not delete the last admin user [uid: %d]", err.UID)
73}
74
75// ErrNoPendingRepoTransfer is an error type for repositories without a pending
76// transfer request
77type ErrNoPendingRepoTransfer struct {
78 RepoID int64
79}
80
81func (err ErrNoPendingRepoTransfer) Error() string {
82 return fmt.Sprintf("repository doesn't have a pending transfer [repo_id: %d]", err.RepoID)
83}
84
85// IsErrNoPendingTransfer is an error type when a repository has no pending
86// transfers
87func IsErrNoPendingTransfer(err error) bool {
88 _, ok := err.(ErrNoPendingRepoTransfer)
89 return ok
90}
91
92func (err ErrNoPendingRepoTransfer) Unwrap() error {
93 return util.ErrNotExist
94}
95
96// ErrRepoTransferInProgress represents the state of a repository that has an
97// ongoing transfer
98type ErrRepoTransferInProgress struct {
99 Uname string
100 Name string
101}
102
103// IsErrRepoTransferInProgress checks if an error is a ErrRepoTransferInProgress.
104func IsErrRepoTransferInProgress(err error) bool {
105 _, ok := err.(ErrRepoTransferInProgress)
106 return ok
107}
108
109func (err ErrRepoTransferInProgress) Error() string {
110 return fmt.Sprintf("repository is already being transferred [uname: %s, name: %s]", err.Uname, err.Name)
111}
112
113func (err ErrRepoTransferInProgress) Unwrap() error {
114 return util.ErrAlreadyExist
115}
116
117// ErrInvalidCloneAddr represents a "InvalidCloneAddr" kind of error.
118type ErrInvalidCloneAddr struct {
119 Host string
120 IsURLError bool
121 IsInvalidPath bool
122 IsProtocolInvalid bool
123 IsPermissionDenied bool
124 LocalPath bool
125}
126
127// IsErrInvalidCloneAddr checks if an error is a ErrInvalidCloneAddr.
128func IsErrInvalidCloneAddr(err error) bool {
129 _, ok := err.(*ErrInvalidCloneAddr)
130 return ok
131}
132
133func (err *ErrInvalidCloneAddr) Error() string {
134 if err.IsInvalidPath {
135 return fmt.Sprintf("migration/cloning from '%s' is not allowed: the provided path is invalid", err.Host)
136 }
137 if err.IsProtocolInvalid {
138 return fmt.Sprintf("migration/cloning from '%s' is not allowed: the provided url protocol is not allowed", err.Host)
139 }
140 if err.IsPermissionDenied {
141 return fmt.Sprintf("migration/cloning from '%s' is not allowed.", err.Host)
142 }
143 if err.IsURLError {
144 return fmt.Sprintf("migration/cloning from '%s' is not allowed: the provided url is invalid", err.Host)
145 }
146
147 return fmt.Sprintf("migration/cloning from '%s' is not allowed", err.Host)
148}
149
150func (err *ErrInvalidCloneAddr) Unwrap() error {
151 return util.ErrInvalidArgument
152}
153
154// ErrInvalidTagName represents a "InvalidTagName" kind of error.
155type ErrInvalidTagName struct {
156 TagName string
157}
158
159// IsErrInvalidTagName checks if an error is a ErrInvalidTagName.
160func IsErrInvalidTagName(err error) bool {
161 _, ok := err.(ErrInvalidTagName)
162 return ok
163}
164
165func (err ErrInvalidTagName) Error() string {
166 return fmt.Sprintf("release tag name is not valid [tag_name: %s]", err.TagName)
167}
168
169func (err ErrInvalidTagName) Unwrap() error {
170 return util.ErrInvalidArgument
171}
172
173// ErrProtectedTagName represents a "ProtectedTagName" kind of error.
174type ErrProtectedTagName struct {
175 TagName string
176}
177
178// IsErrProtectedTagName checks if an error is a ErrProtectedTagName.
179func IsErrProtectedTagName(err error) bool {
180 _, ok := err.(ErrProtectedTagName)
181 return ok
182}
183
184func (err ErrProtectedTagName) Error() string {
185 return fmt.Sprintf("release tag name is protected [tag_name: %s]", err.TagName)
186}
187
188func (err ErrProtectedTagName) Unwrap() error {
189 return util.ErrPermissionDenied
190}
191
192// ErrRepoFileAlreadyExists represents a "RepoFileAlreadyExist" kind of error.
193type ErrRepoFileAlreadyExists struct {
194 Path string
195}
196
197// IsErrRepoFileAlreadyExists checks if an error is a ErrRepoFileAlreadyExists.
198func IsErrRepoFileAlreadyExists(err error) bool {
199 _, ok := err.(ErrRepoFileAlreadyExists)
200 return ok
201}
202
203func (err ErrRepoFileAlreadyExists) Error() string {
204 return fmt.Sprintf("repository file already exists [path: %s]", err.Path)
205}
206
207func (err ErrRepoFileAlreadyExists) Unwrap() error {
208 return util.ErrAlreadyExist
209}
210
211// ErrRepoFileDoesNotExist represents a "RepoFileDoesNotExist" kind of error.
212type ErrRepoFileDoesNotExist struct {
213 Path string
214 Name string
215}
216
217// IsErrRepoFileDoesNotExist checks if an error is a ErrRepoDoesNotExist.
218func IsErrRepoFileDoesNotExist(err error) bool {
219 _, ok := err.(ErrRepoFileDoesNotExist)
220 return ok
221}
222
223func (err ErrRepoFileDoesNotExist) Error() string {
224 return fmt.Sprintf("repository file does not exist [path: %s]", err.Path)
225}
226
227func (err ErrRepoFileDoesNotExist) Unwrap() error {
228 return util.ErrNotExist
229}
230
231// ErrFilenameInvalid represents a "FilenameInvalid" kind of error.
232type ErrFilenameInvalid struct {
233 Path string
234}
235
236// IsErrFilenameInvalid checks if an error is an ErrFilenameInvalid.
237func IsErrFilenameInvalid(err error) bool {
238 _, ok := err.(ErrFilenameInvalid)
239 return ok
240}
241
242func (err ErrFilenameInvalid) Error() string {
243 return fmt.Sprintf("path contains a malformed path component [path: %s]", err.Path)
244}
245
246func (err ErrFilenameInvalid) Unwrap() error {
247 return util.ErrInvalidArgument
248}
249
250// ErrUserCannotCommit represents "UserCannotCommit" kind of error.
251type ErrUserCannotCommit struct {
252 UserName string
253}
254
255// IsErrUserCannotCommit checks if an error is an ErrUserCannotCommit.
256func IsErrUserCannotCommit(err error) bool {
257 _, ok := err.(ErrUserCannotCommit)
258 return ok
259}
260
261func (err ErrUserCannotCommit) Error() string {
262 return fmt.Sprintf("user cannot commit to repo [user: %s]", err.UserName)
263}
264
265func (err ErrUserCannotCommit) Unwrap() error {
266 return util.ErrPermissionDenied
267}
268
269// ErrFilePathInvalid represents a "FilePathInvalid" kind of error.
270type ErrFilePathInvalid struct {
271 Message string
272 Path string
273 Name string
274 Type git.EntryMode
275}
276
277// IsErrFilePathInvalid checks if an error is an ErrFilePathInvalid.
278func IsErrFilePathInvalid(err error) bool {
279 _, ok := err.(ErrFilePathInvalid)
280 return ok
281}
282
283func (err ErrFilePathInvalid) Error() string {
284 if err.Message != "" {
285 return err.Message
286 }
287 return fmt.Sprintf("path is invalid [path: %s]", err.Path)
288}
289
290func (err ErrFilePathInvalid) Unwrap() error {
291 return util.ErrInvalidArgument
292}
293
294// ErrFilePathProtected represents a "FilePathProtected" kind of error.
295type ErrFilePathProtected struct {
296 Message string
297 Path string
298}
299
300// IsErrFilePathProtected checks if an error is an ErrFilePathProtected.
301func IsErrFilePathProtected(err error) bool {
302 _, ok := err.(ErrFilePathProtected)
303 return ok
304}
305
306func (err ErrFilePathProtected) Error() string {
307 if err.Message != "" {
308 return err.Message
309 }
310 return fmt.Sprintf("path is protected and can not be changed [path: %s]", err.Path)
311}
312
313func (err ErrFilePathProtected) Unwrap() error {
314 return util.ErrPermissionDenied
315}
316
317// ErrDisallowedToMerge represents an error that a branch is protected and the current user is not allowed to modify it.
318type ErrDisallowedToMerge struct {
319 Reason string
320}
321
322// IsErrDisallowedToMerge checks if an error is an ErrDisallowedToMerge.
323func IsErrDisallowedToMerge(err error) bool {
324 _, ok := err.(ErrDisallowedToMerge)
325 return ok
326}
327
328func (err ErrDisallowedToMerge) Error() string {
329 return fmt.Sprintf("not allowed to merge [reason: %s]", err.Reason)
330}
331
332func (err ErrDisallowedToMerge) Unwrap() error {
333 return util.ErrPermissionDenied
334}
335
336// ErrTagAlreadyExists represents an error that tag with such name already exists.
337type ErrTagAlreadyExists struct {
338 TagName string
339}
340
341// IsErrTagAlreadyExists checks if an error is an ErrTagAlreadyExists.
342func IsErrTagAlreadyExists(err error) bool {
343 _, ok := err.(ErrTagAlreadyExists)
344 return ok
345}
346
347func (err ErrTagAlreadyExists) Error() string {
348 return fmt.Sprintf("tag already exists [name: %s]", err.TagName)
349}
350
351func (err ErrTagAlreadyExists) Unwrap() error {
352 return util.ErrAlreadyExist
353}
354
355// ErrSHADoesNotMatch represents a "SHADoesNotMatch" kind of error.
356type ErrSHADoesNotMatch struct {
357 Path string
358 GivenSHA string
359 CurrentSHA string
360}
361
362// IsErrSHADoesNotMatch checks if an error is a ErrSHADoesNotMatch.
363func IsErrSHADoesNotMatch(err error) bool {
364 _, ok := err.(ErrSHADoesNotMatch)
365 return ok
366}
367
368func (err ErrSHADoesNotMatch) Error() string {
369 return fmt.Sprintf("sha does not match [given: %s, expected: %s]", err.GivenSHA, err.CurrentSHA)
370}
371
372// ErrSHANotFound represents a "SHADoesNotMatch" kind of error.
373type ErrSHANotFound struct {
374 SHA string
375}
376
377// IsErrSHANotFound checks if an error is a ErrSHANotFound.
378func IsErrSHANotFound(err error) bool {
379 _, ok := err.(ErrSHANotFound)
380 return ok
381}
382
383func (err ErrSHANotFound) Error() string {
384 return fmt.Sprintf("sha not found [%s]", err.SHA)
385}
386
387func (err ErrSHANotFound) Unwrap() error {
388 return util.ErrNotExist
389}
390
391// ErrCommitIDDoesNotMatch represents a "CommitIDDoesNotMatch" kind of error.
392type ErrCommitIDDoesNotMatch struct {
393 GivenCommitID string
394 CurrentCommitID string
395}
396
397// IsErrCommitIDDoesNotMatch checks if an error is a ErrCommitIDDoesNotMatch.
398func IsErrCommitIDDoesNotMatch(err error) bool {
399 _, ok := err.(ErrCommitIDDoesNotMatch)
400 return ok
401}
402
403func (err ErrCommitIDDoesNotMatch) Error() string {
404 return fmt.Sprintf("file CommitID does not match [given: %s, expected: %s]", err.GivenCommitID, err.CurrentCommitID)
405}
406
407// ErrSHAOrCommitIDNotProvided represents a "SHAOrCommitIDNotProvided" kind of error.
408type ErrSHAOrCommitIDNotProvided struct{}
409
410// IsErrSHAOrCommitIDNotProvided checks if an error is a ErrSHAOrCommitIDNotProvided.
411func IsErrSHAOrCommitIDNotProvided(err error) bool {
412 _, ok := err.(ErrSHAOrCommitIDNotProvided)
413 return ok
414}
415
416func (err ErrSHAOrCommitIDNotProvided) Error() string {
417 return "a SHA or commit ID must be proved when updating a file"
418}
419
420// ErrInvalidMergeStyle represents an error if merging with disabled merge strategy
421type ErrInvalidMergeStyle struct {
422 ID int64
423 Style repo_model.MergeStyle
424}
425
426// IsErrInvalidMergeStyle checks if an error is a ErrInvalidMergeStyle.
427func IsErrInvalidMergeStyle(err error) bool {
428 _, ok := err.(ErrInvalidMergeStyle)
429 return ok
430}
431
432func (err ErrInvalidMergeStyle) Error() string {
433 return fmt.Sprintf("merge strategy is not allowed or is invalid [repo_id: %d, strategy: %s]",
434 err.ID, err.Style)
435}
436
437func (err ErrInvalidMergeStyle) Unwrap() error {
438 return util.ErrInvalidArgument
439}
440
441// ErrMergeConflicts represents an error if merging fails with a conflict
442type ErrMergeConflicts struct {
443 Style repo_model.MergeStyle
444 StdOut string
445 StdErr string
446 Err error
447}
448
449// IsErrMergeConflicts checks if an error is a ErrMergeConflicts.
450func IsErrMergeConflicts(err error) bool {
451 _, ok := err.(ErrMergeConflicts)
452 return ok
453}
454
455func (err ErrMergeConflicts) Error() string {
456 return fmt.Sprintf("Merge Conflict Error: %v: %s\n%s", err.Err, err.StdErr, err.StdOut)
457}
458
459// ErrMergeUnrelatedHistories represents an error if merging fails due to unrelated histories
460type ErrMergeUnrelatedHistories struct {
461 Style repo_model.MergeStyle
462 StdOut string
463 StdErr string
464 Err error
465}
466
467// IsErrMergeUnrelatedHistories checks if an error is a ErrMergeUnrelatedHistories.
468func IsErrMergeUnrelatedHistories(err error) bool {
469 _, ok := err.(ErrMergeUnrelatedHistories)
470 return ok
471}
472
473func (err ErrMergeUnrelatedHistories) Error() string {
474 return fmt.Sprintf("Merge UnrelatedHistories Error: %v: %s\n%s", err.Err, err.StdErr, err.StdOut)
475}
476
477// ErrMergeDivergingFastForwardOnly represents an error if a fast-forward-only merge fails because the branches diverge
478type ErrMergeDivergingFastForwardOnly struct {
479 StdOut string
480 StdErr string
481 Err error
482}
483
484// IsErrMergeDivergingFastForwardOnly checks if an error is a ErrMergeDivergingFastForwardOnly.
485func IsErrMergeDivergingFastForwardOnly(err error) bool {
486 _, ok := err.(ErrMergeDivergingFastForwardOnly)
487 return ok
488}
489
490func (err ErrMergeDivergingFastForwardOnly) Error() string {
491 return fmt.Sprintf("Merge DivergingFastForwardOnly Error: %v: %s\n%s", err.Err, err.StdErr, err.StdOut)
492}
493
494// ErrRebaseConflicts represents an error if rebase fails with a conflict
495type ErrRebaseConflicts struct {
496 Style repo_model.MergeStyle
497 CommitSHA string
498 StdOut string
499 StdErr string
500 Err error
501}
502
503// IsErrRebaseConflicts checks if an error is a ErrRebaseConflicts.
504func IsErrRebaseConflicts(err error) bool {
505 _, ok := err.(ErrRebaseConflicts)
506 return ok
507}
508
509func (err ErrRebaseConflicts) Error() string {
510 return fmt.Sprintf("Rebase Error: %v: Whilst Rebasing: %s\n%s\n%s", err.Err, err.CommitSHA, err.StdErr, err.StdOut)
511}
512
513// ErrPullRequestHasMerged represents a "PullRequestHasMerged"-error
514type ErrPullRequestHasMerged struct {
515 ID int64
516 IssueID int64
517 HeadRepoID int64
518 BaseRepoID int64
519 HeadBranch string
520 BaseBranch string
521}
522
523// IsErrPullRequestHasMerged checks if an error is a ErrPullRequestHasMerged.
524func IsErrPullRequestHasMerged(err error) bool {
525 _, ok := err.(ErrPullRequestHasMerged)
526 return ok
527}
528
529// Error does pretty-printing :D
530func (err ErrPullRequestHasMerged) Error() string {
531 return fmt.Sprintf("pull request has merged [id: %d, issue_id: %d, head_repo_id: %d, base_repo_id: %d, head_branch: %s, base_branch: %s]",
532 err.ID, err.IssueID, err.HeadRepoID, err.BaseRepoID, err.HeadBranch, err.BaseBranch)
533}