feat: bied dezelfde acties als de UI aan via /api/v1
De webhandlers en de REST-API delen één servicelaag. Tokens krijgen scopes en een vervaldatum, en een SSH-sessie roept dezelfde handlers aan. Co-authored-by: tim <tim@timfalken.com>
@@ -124,6 +124,7 @@ func serve(args []string) error {
124
124
Listen: cfg.SSH.Listen, Store: st, GitBin: cfg.Git.Binary, Storage: dataPath,
125
125
HostKey: filepath.Join(cfg.StatePath, "ssh", "host_ed25519"), Log: log,
126
126
OnPush: srv.AfterPush,
127
API: srv.CallAPI,
127
128
}
128
129
go func() {
129
130
if err := sh.Run(ctx); err != nil {
@@ -124,6 +124,7 @@ func serve(args []string) error {124
Listen: cfg.SSH.Listen, Store: st, GitBin: cfg.Git.Binary, Storage: dataPath,124
Listen: cfg.SSH.Listen, Store: st, GitBin: cfg.Git.Binary, Storage: dataPath,125
HostKey: filepath.Join(cfg.StatePath, "ssh", "host_ed25519"), Log: log,125
HostKey: filepath.Join(cfg.StatePath, "ssh", "host_ed25519"), Log: log,126
OnPush: srv.AfterPush,126
OnPush: srv.AfterPush,127
API: srv.CallAPI,127
}128
}128
go func() {129
go func() {129
if err := sh.Run(ctx); err != nil {130
if err := sh.Run(ctx); err != nil {@@ -0,0 +1,125 @@
1
package access
2
3
import (
4
"sort"
5
"strings"
6
7
"gitlab.com/Timfa/bluegit/internal/i18n"
8
)
9
10
const (
11
ScopeAPI = "api"
12
ScopeReadAPI = "read_api"
13
ScopeReadRepo = "read_repository"
14
ScopeWriteRepo = "write_repository"
15
)
16
17
// ScopeClass is het soort aanroep dat een token moet toestaan.
18
type ScopeClass int
19
20
const (
21
ScopePublic ScopeClass = iota
22
ScopeRead
23
ScopeWrite
24
ScopeRepoRead
25
ScopeRepoWrite
26
ScopeAdmin
27
)
28
29
// Scopes is de verzameling rechten op een toegangstoken.
30
// api dekt de hele API en git. read_api is alleen lezen.
31
// read_repository en write_repository gelden voor git en voor
32
// repository-inhoud (bestanden, commits, branches, tags).
33
type Scopes struct {
34
set map[string]bool
35
}
36
37
// ParseScopes maakt een opgeslagen lijst. Leeg wordt api.
38
func ParseScopes(in []string) (string, Scopes, error) {
39
if len(in) == 0 {
40
return ScopeAPI, Scopes{set: map[string]bool{ScopeAPI: true}}, nil
41
}
42
seen := map[string]bool{}
43
var list []string
44
for _, raw := range in {
45
name := strings.TrimSpace(raw)
46
if name == "" {
47
continue
48
}
49
switch name {
50
case ScopeAPI, ScopeReadAPI, ScopeReadRepo, ScopeWriteRepo:
51
default:
52
return "", Scopes{}, i18n.E("err.scopeName", name)
53
}
54
if seen[name] {
55
continue
56
}
57
seen[name] = true
58
list = append(list, name)
59
}
60
if len(list) == 0 {
61
return ScopeAPI, Scopes{set: map[string]bool{ScopeAPI: true}}, nil
62
}
63
sort.Strings(list)
64
return strings.Join(list, ","), Scopes{set: seen}, nil
65
}
66
67
// StoredScopes leest de kommagescheiden kolom. Leeg telt als api.
68
func StoredScopes(raw string) Scopes {
69
raw = strings.TrimSpace(raw)
70
if raw == "" {
71
return Scopes{set: map[string]bool{ScopeAPI: true}}
72
}
73
set := map[string]bool{}
74
for _, part := range strings.Split(raw, ",") {
75
part = strings.TrimSpace(part)
76
if part != "" {
77
set[part] = true
78
}
79
}
80
if len(set) == 0 {
81
set[ScopeAPI] = true
82
}
83
return Scopes{set: set}
84
}
85
86
func (s Scopes) List() []string {
87
var out []string
88
for name := range s.set {
89
out = append(out, name)
90
}
91
sort.Strings(out)
92
return out
93
}
94
95
func (s Scopes) APIWrite() bool { return s.set[ScopeAPI] }
96
func (s Scopes) APIRead() bool { return s.set[ScopeAPI] || s.set[ScopeReadAPI] }
97
func (s Scopes) RepoWrite() bool {
98
return s.set[ScopeAPI] || s.set[ScopeWriteRepo]
99
}
100
func (s Scopes) RepoRead() bool {
101
return s.RepoWrite() || s.set[ScopeReadRepo]
102
}
103
104
// Allows meldt of deze scopes de klasse dekken.
105
func (s Scopes) Allows(class ScopeClass) bool {
106
switch class {
107
case ScopePublic:
108
return true
109
case ScopeRead:
110
return s.APIRead()
111
case ScopeWrite, ScopeAdmin:
112
return s.APIWrite()
113
case ScopeRepoRead:
114
return s.APIRead() || s.RepoRead()
115
case ScopeRepoWrite:
116
return s.APIWrite() || s.RepoWrite()
117
default:
118
return false
119
}
120
}
121
122
// AllScopes is wat een SSH-sessie mag: dezelfde rechten als de UI.
123
func AllScopes() Scopes {
124
return Scopes{set: map[string]bool{ScopeAPI: true}}
125
}
@@ -0,0 +1,125 @@1
package access2
3
import (4
"sort"5
"strings"6
7
"gitlab.com/Timfa/bluegit/internal/i18n"8
)9
10
const (11
ScopeAPI = "api"12
ScopeReadAPI = "read_api"13
ScopeReadRepo = "read_repository"14
ScopeWriteRepo = "write_repository"15
)16
17
// ScopeClass is het soort aanroep dat een token moet toestaan.18
type ScopeClass int19
20
const (21
ScopePublic ScopeClass = iota22
ScopeRead23
ScopeWrite24
ScopeRepoRead25
ScopeRepoWrite26
ScopeAdmin27
)28
29
// Scopes is de verzameling rechten op een toegangstoken.30
// api dekt de hele API en git. read_api is alleen lezen.31
// read_repository en write_repository gelden voor git en voor32
// repository-inhoud (bestanden, commits, branches, tags).33
type Scopes struct {34
set map[string]bool35
}36
37
// ParseScopes maakt een opgeslagen lijst. Leeg wordt api.38
func ParseScopes(in []string) (string, Scopes, error) {39
if len(in) == 0 {40
return ScopeAPI, Scopes{set: map[string]bool{ScopeAPI: true}}, nil41
}42
seen := map[string]bool{}43
var list []string44
for _, raw := range in {45
name := strings.TrimSpace(raw)46
if name == "" {47
continue48
}49
switch name {50
case ScopeAPI, ScopeReadAPI, ScopeReadRepo, ScopeWriteRepo:51
default:52
return "", Scopes{}, i18n.E("err.scopeName", name)53
}54
if seen[name] {55
continue56
}57
seen[name] = true58
list = append(list, name)59
}60
if len(list) == 0 {61
return ScopeAPI, Scopes{set: map[string]bool{ScopeAPI: true}}, nil62
}63
sort.Strings(list)64
return strings.Join(list, ","), Scopes{set: seen}, nil65
}66
67
// StoredScopes leest de kommagescheiden kolom. Leeg telt als api.68
func StoredScopes(raw string) Scopes {69
raw = strings.TrimSpace(raw)70
if raw == "" {71
return Scopes{set: map[string]bool{ScopeAPI: true}}72
}73
set := map[string]bool{}74
for _, part := range strings.Split(raw, ",") {75
part = strings.TrimSpace(part)76
if part != "" {77
set[part] = true78
}79
}80
if len(set) == 0 {81
set[ScopeAPI] = true82
}83
return Scopes{set: set}84
}85
86
func (s Scopes) List() []string {87
var out []string88
for name := range s.set {89
out = append(out, name)90
}91
sort.Strings(out)92
return out93
}94
95
func (s Scopes) APIWrite() bool { return s.set[ScopeAPI] }96
func (s Scopes) APIRead() bool { return s.set[ScopeAPI] || s.set[ScopeReadAPI] }97
func (s Scopes) RepoWrite() bool {98
return s.set[ScopeAPI] || s.set[ScopeWriteRepo]99
}100
func (s Scopes) RepoRead() bool {101
return s.RepoWrite() || s.set[ScopeReadRepo]102
}103
104
// Allows meldt of deze scopes de klasse dekken.105
func (s Scopes) Allows(class ScopeClass) bool {106
switch class {107
case ScopePublic:108
return true109
case ScopeRead:110
return s.APIRead()111
case ScopeWrite, ScopeAdmin:112
return s.APIWrite()113
case ScopeRepoRead:114
return s.APIRead() || s.RepoRead()115
case ScopeRepoWrite:116
return s.APIWrite() || s.RepoWrite()117
default:118
return false119
}120
}121
122
// AllScopes is wat een SSH-sessie mag: dezelfde rechten als de UI.123
func AllScopes() Scopes {124
return Scopes{set: map[string]bool{ScopeAPI: true}}125
}@@ -113,6 +113,14 @@ func ApplySuggestions(files map[string]string, edits []SuggestionEdit) (map[stri
113
113
// Git draait met een eigen HOME en TMPDIR onder work, niet met die van het proces:
114
114
// ProtectHome maakt de homedirectory onleesbaar en /tmp is niet de werkmap.
115
115
func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, role access.Role, patterns []string) error {
116
return CommitChanges(ctx, gitBin, bare, work, branch, author, email, title, description, files, nil, role, patterns)
117
}
118
119
// CommitChanges schrijft files, verwijdert paden en pusht één commit.
120
func CommitChanges(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, deletes []string, role access.Role, patterns []string) error {
121
if len(files) == 0 && len(deletes) == 0 {
122
return i18n.E("err.commitEmpty")
123
}
116
124
repo, env, err := prepareWork(work, author, email)
117
125
if err != nil {
118
126
return classifyGit(err)
@@ -142,9 +150,19 @@ func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, ema
142
150
paths = append(paths, path)
143
151
}
144
152
sort.Strings(paths)
145
args := append([]string{"-C", repo, "add", "--"}, paths...)
146
if _, err := run(ctx, gitBin, env, args...); err != nil {
147
return classifyGit(err)
153
if len(paths) > 0 {
154
args := append([]string{"-C", repo, "add", "--"}, paths...)
155
if _, err := run(ctx, gitBin, env, args...); err != nil {
156
return classifyGit(err)
157
}
158
}
159
for _, path := range deletes {
160
if !safeWorkPath(path) {
161
return i18n.E("err.sugFile")
162
}
163
if _, err := run(ctx, gitBin, env, "-C", repo, "rm", "-f", "--ignore-unmatch", "--", path); err != nil {
164
return classifyGit(err)
165
}
148
166
}
149
167
commit := []string{"-C", repo, "-c", "commit.gpgsign=false", "commit", "-m", title}
150
168
if strings.TrimSpace(description) != "" {
@@ -113,6 +113,14 @@ func ApplySuggestions(files map[string]string, edits []SuggestionEdit) (map[stri113
// Git draait met een eigen HOME en TMPDIR onder work, niet met die van het proces:113
// Git draait met een eigen HOME en TMPDIR onder work, niet met die van het proces:114
// ProtectHome maakt de homedirectory onleesbaar en /tmp is niet de werkmap.114
// ProtectHome maakt de homedirectory onleesbaar en /tmp is niet de werkmap.115
func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, role access.Role, patterns []string) error {115
func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, role access.Role, patterns []string) error {116
return CommitChanges(ctx, gitBin, bare, work, branch, author, email, title, description, files, nil, role, patterns)117
}118
119
// CommitChanges schrijft files, verwijdert paden en pusht één commit.120
func CommitChanges(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, deletes []string, role access.Role, patterns []string) error {121
if len(files) == 0 && len(deletes) == 0 {122
return i18n.E("err.commitEmpty")123
}116
repo, env, err := prepareWork(work, author, email)124
repo, env, err := prepareWork(work, author, email)117
if err != nil {125
if err != nil {118
return classifyGit(err)126
return classifyGit(err)@@ -142,9 +150,19 @@ func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, ema142
paths = append(paths, path)150
paths = append(paths, path)143
}151
}144
sort.Strings(paths)152
sort.Strings(paths)145
args := append([]string{"-C", repo, "add", "--"}, paths...)153
if len(paths) > 0 {146
if _, err := run(ctx, gitBin, env, args...); err != nil {154
args := append([]string{"-C", repo, "add", "--"}, paths...)147
return classifyGit(err)155
if _, err := run(ctx, gitBin, env, args...); err != nil {156
return classifyGit(err)157
}158
}159
for _, path := range deletes {160
if !safeWorkPath(path) {161
return i18n.E("err.sugFile")162
}163
if _, err := run(ctx, gitBin, env, "-C", repo, "rm", "-f", "--ignore-unmatch", "--", path); err != nil {164
return classifyGit(err)165
}148
}166
}149
commit := []string{"-C", repo, "-c", "commit.gpgsign=false", "commit", "-m", title}167
commit := []string{"-C", repo, "-c", "commit.gpgsign=false", "commit", "-m", title}150
if strings.TrimSpace(description) != "" {168
if strings.TrimSpace(description) != "" {@@ -0,0 +1,68 @@
1
package i18n
2
3
func init() {
4
addCatalog(en, apiEN)
5
addCatalog(nl, apiNL)
6
addCatalog(de, apiDE)
7
addCatalog(fr, apiFR)
8
}
9
10
var apiEN = map[string]string{
11
"err.tokenExpired": "token is expired",
12
"err.scopeName": "unknown token scope %s",
13
"err.commitEmpty": "commit has no file changes",
14
"err.apiAuth": "a personal access token is required",
15
"err.apiScope": "this token does not have the required scope",
16
"err.jobState": "the job is not in a state that allows this action",
17
"err.mrBlocked": "%s",
18
"info.api.title": "API",
19
"info.api.lead": "Everything the web interface can do is also available under /api/v1. The machine-readable description is the OpenAPI document.",
20
"info.api.auth": "Send the token as Authorization: Bearer, as the PRIVATE-TOKEN header, or as the password of HTTP basic authentication. Git over HTTP uses the same token. Scopes are api, read_api, read_repository and write_repository. api covers the whole API and git. A token can expire.",
21
"info.api.ssh": "An SSH key can call the same handlers: ssh git@host api METHOD /api/v1/... with a JSON body on stdin. The exit status is 0 when the HTTP status is below 400. The numeric status is written to stderr.",
22
"info.api.spec": "OpenAPI",
23
}
24
25
var apiNL = map[string]string{
26
"err.tokenExpired": "token is verlopen",
27
"err.scopeName": "onbekende tokenscope %s",
28
"err.commitEmpty": "commit heeft geen bestandswijzigingen",
29
"err.apiAuth": "een persoonlijk toegangstoken is verplicht",
30
"err.apiScope": "dit token heeft de vereiste scope niet",
31
"err.jobState": "de job staat niet in een toestand die deze actie toelaat",
32
"err.mrBlocked": "%s",
33
"info.api.title": "API",
34
"info.api.lead": "Alles wat de webinterface kan, kan ook via /api/v1. De machine-leesbare beschrijving is het OpenAPI-document.",
35
"info.api.auth": "Stuur het token als Authorization: Bearer, als PRIVATE-TOKEN-header, of als wachtwoord van HTTP basic. Git over HTTP gebruikt hetzelfde token. Scopes zijn api, read_api, read_repository en write_repository. api dekt de hele API en git. Een token kan verlopen.",
36
"info.api.ssh": "Een SSH-sleutel roept dezelfde handlers aan: ssh git@host api METHOD /api/v1/... met een JSON-body op stdin. De exitstatus is 0 als de HTTP-status onder 400 ligt. Het statusgetal gaat naar stderr.",
37
"info.api.spec": "OpenAPI",
38
}
39
40
var apiDE = map[string]string{
41
"err.tokenExpired": "Token ist abgelaufen",
42
"err.scopeName": "unbekannter Token-Scope %s",
43
"err.commitEmpty": "Commit hat keine Dateiänderungen",
44
"err.apiAuth": "ein persönliches Zugriffstoken ist erforderlich",
45
"err.apiScope": "dieses Token hat den nötigen Scope nicht",
46
"err.jobState": "der Job ist nicht in einem Zustand, der diese Aktion erlaubt",
47
"err.mrBlocked": "%s",
48
"info.api.title": "API",
49
"info.api.lead": "Alles, was die Weboberfläche kann, geht auch über /api/v1. Die maschinenlesbare Beschreibung ist das OpenAPI-Dokument.",
50
"info.api.auth": "Sende das Token als Authorization: Bearer, als PRIVATE-TOKEN-Header oder als Passwort von HTTP Basic. Git über HTTP nutzt dasselbe Token. Scopes sind api, read_api, read_repository und write_repository. api deckt die ganze API und Git ab. Ein Token kann ablaufen.",
51
"info.api.ssh": "Ein SSH-Schlüssel ruft dieselben Handler auf: ssh git@host api METHOD /api/v1/... mit einem JSON-Body auf stdin. Der Exit-Status ist 0, wenn der HTTP-Status unter 400 liegt. Die Statuszahl geht nach stderr.",
52
"info.api.spec": "OpenAPI",
53
}
54
55
var apiFR = map[string]string{
56
"err.tokenExpired": "le jeton a expiré",
57
"err.scopeName": "portée de jeton inconnue %s",
58
"err.commitEmpty": "le commit ne modifie aucun fichier",
59
"err.apiAuth": "un jeton d'accès personnel est obligatoire",
60
"err.apiScope": "ce jeton n'a pas la portée requise",
61
"err.jobState": "le job n'est pas dans un état qui permet cette action",
62
"err.mrBlocked": "%s",
63
"info.api.title": "API",
64
"info.api.lead": "Tout ce que l'interface web sait faire est aussi disponible sous /api/v1. La description lisible par une machine est le document OpenAPI.",
65
"info.api.auth": "Envoie le jeton dans Authorization: Bearer, dans l'en-tête PRIVATE-TOKEN, ou comme mot de passe de l'authentification HTTP basic. Git via HTTP utilise le même jeton. Les portées sont api, read_api, read_repository et write_repository. api couvre toute l'API et git. Un jeton peut expirer.",
66
"info.api.ssh": "Une clé SSH appelle les mêmes handlers : ssh git@host api METHOD /api/v1/... avec un corps JSON sur stdin. Le code de sortie est 0 si le statut HTTP est inférieur à 400. Le numéro de statut va sur stderr.",
67
"info.api.spec": "OpenAPI",
68
}
@@ -0,0 +1,68 @@1
package i18n2
3
func init() {4
addCatalog(en, apiEN)5
addCatalog(nl, apiNL)6
addCatalog(de, apiDE)7
addCatalog(fr, apiFR)8
}9
10
var apiEN = map[string]string{11
"err.tokenExpired": "token is expired",12
"err.scopeName": "unknown token scope %s",13
"err.commitEmpty": "commit has no file changes",14
"err.apiAuth": "a personal access token is required",15
"err.apiScope": "this token does not have the required scope",16
"err.jobState": "the job is not in a state that allows this action",17
"err.mrBlocked": "%s",18
"info.api.title": "API",19
"info.api.lead": "Everything the web interface can do is also available under /api/v1. The machine-readable description is the OpenAPI document.",20
"info.api.auth": "Send the token as Authorization: Bearer, as the PRIVATE-TOKEN header, or as the password of HTTP basic authentication. Git over HTTP uses the same token. Scopes are api, read_api, read_repository and write_repository. api covers the whole API and git. A token can expire.",21
"info.api.ssh": "An SSH key can call the same handlers: ssh git@host api METHOD /api/v1/... with a JSON body on stdin. The exit status is 0 when the HTTP status is below 400. The numeric status is written to stderr.",22
"info.api.spec": "OpenAPI",23
}24
25
var apiNL = map[string]string{26
"err.tokenExpired": "token is verlopen",27
"err.scopeName": "onbekende tokenscope %s",28
"err.commitEmpty": "commit heeft geen bestandswijzigingen",29
"err.apiAuth": "een persoonlijk toegangstoken is verplicht",30
"err.apiScope": "dit token heeft de vereiste scope niet",31
"err.jobState": "de job staat niet in een toestand die deze actie toelaat",32
"err.mrBlocked": "%s",33
"info.api.title": "API",34
"info.api.lead": "Alles wat de webinterface kan, kan ook via /api/v1. De machine-leesbare beschrijving is het OpenAPI-document.",35
"info.api.auth": "Stuur het token als Authorization: Bearer, als PRIVATE-TOKEN-header, of als wachtwoord van HTTP basic. Git over HTTP gebruikt hetzelfde token. Scopes zijn api, read_api, read_repository en write_repository. api dekt de hele API en git. Een token kan verlopen.",36
"info.api.ssh": "Een SSH-sleutel roept dezelfde handlers aan: ssh git@host api METHOD /api/v1/... met een JSON-body op stdin. De exitstatus is 0 als de HTTP-status onder 400 ligt. Het statusgetal gaat naar stderr.",37
"info.api.spec": "OpenAPI",38
}39
40
var apiDE = map[string]string{41
"err.tokenExpired": "Token ist abgelaufen",42
"err.scopeName": "unbekannter Token-Scope %s",43
"err.commitEmpty": "Commit hat keine Dateiänderungen",44
"err.apiAuth": "ein persönliches Zugriffstoken ist erforderlich",45
"err.apiScope": "dieses Token hat den nötigen Scope nicht",46
"err.jobState": "der Job ist nicht in einem Zustand, der diese Aktion erlaubt",47
"err.mrBlocked": "%s",48
"info.api.title": "API",49
"info.api.lead": "Alles, was die Weboberfläche kann, geht auch über /api/v1. Die maschinenlesbare Beschreibung ist das OpenAPI-Dokument.",50
"info.api.auth": "Sende das Token als Authorization: Bearer, als PRIVATE-TOKEN-Header oder als Passwort von HTTP Basic. Git über HTTP nutzt dasselbe Token. Scopes sind api, read_api, read_repository und write_repository. api deckt die ganze API und Git ab. Ein Token kann ablaufen.",51
"info.api.ssh": "Ein SSH-Schlüssel ruft dieselben Handler auf: ssh git@host api METHOD /api/v1/... mit einem JSON-Body auf stdin. Der Exit-Status ist 0, wenn der HTTP-Status unter 400 liegt. Die Statuszahl geht nach stderr.",52
"info.api.spec": "OpenAPI",53
}54
55
var apiFR = map[string]string{56
"err.tokenExpired": "le jeton a expiré",57
"err.scopeName": "portée de jeton inconnue %s",58
"err.commitEmpty": "le commit ne modifie aucun fichier",59
"err.apiAuth": "un jeton d'accès personnel est obligatoire",60
"err.apiScope": "ce jeton n'a pas la portée requise",61
"err.jobState": "le job n'est pas dans un état qui permet cette action",62
"err.mrBlocked": "%s",63
"info.api.title": "API",64
"info.api.lead": "Tout ce que l'interface web sait faire est aussi disponible sous /api/v1. La description lisible par une machine est le document OpenAPI.",65
"info.api.auth": "Envoie le jeton dans Authorization: Bearer, dans l'en-tête PRIVATE-TOKEN, ou comme mot de passe de l'authentification HTTP basic. Git via HTTP utilise le même jeton. Les portées sont api, read_api, read_repository et write_repository. api couvre toute l'API et git. Un jeton peut expirer.",66
"info.api.ssh": "Une clé SSH appelle les mêmes handlers : ssh git@host api METHOD /api/v1/... avec un corps JSON sur stdin. Le code de sortie est 0 si le statut HTTP est inférieur à 400. Le numéro de statut va sur stderr.",67
"info.api.spec": "OpenAPI",68
}@@ -1,7 +1,6 @@
1
1
package server
2
2
3
3
import (
4
"encoding/json"
5
4
"io"
6
5
"net/http"
7
6
"os"
@@ -9,11 +8,8 @@ import (
9
8
"strings"
10
9
11
10
"gitlab.com/Timfa/bluegit/internal/access"
12
"gitlab.com/Timfa/bluegit/internal/gitrepo"
13
11
"gitlab.com/Timfa/bluegit/internal/i18n"
14
"gitlab.com/Timfa/bluegit/internal/names"
15
12
"gitlab.com/Timfa/bluegit/internal/store"
16
"gitlab.com/Timfa/bluegit/internal/webhook"
17
13
)
18
14
19
15
type releaseRequest struct {
@@ -29,116 +25,42 @@ type releaseRequest struct {
29
25
}
30
26
31
27
func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) {
32
if s.StoragePath() == "" {
33
http.Error(w, s.noStorageText(r), http.StatusServiceUnavailable)
34
return
35
}
36
28
repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
37
29
if err != nil {
38
http.NotFound(w, r)
30
s.writeAPIErr(w, r, fail(http.StatusNotFound, i18n.E("err.notFound")))
39
31
return
40
32
}
41
token := bearer(r)
33
token := tokenFrom(r)
42
34
var job store.Job
43
var author int64
44
var actor store.User
35
var author store.User
45
36
if strings.HasPrefix(token, "bgj_") {
46
37
job, err = s.Store.JobByToken(r.Context(), token)
47
38
if err != nil || job.RepoID != repo.ID || job.Status != "running" {
48
http.Error(w, s.tr(r, "err.jobToken"), http.StatusUnauthorized)
39
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.jobToken")))
49
40
return
50
41
}
51
} else if strings.HasPrefix(token, "bg_") {
52
u, err := s.Store.UserByToken(r.Context(), token)
53
if err != nil {
54
http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)
42
} else {
43
author = apiUser(r)
44
if author.ID == 0 {
45
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.apiAuth")))
55
46
return
56
47
}
57
role, err := s.Store.EffectiveRole(r.Context(), u.ID, repo.ID)
48
role, err := s.Store.EffectiveRole(r.Context(), author.ID, repo.ID)
58
49
if err != nil || !role.AtLeast(access.RoleMaintainer) {
59
http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)
50
s.writeAPIErr(w, r, fail(http.StatusForbidden, i18n.E("err.onlyAdmin")))
60
51
return
61
52
}
62
author = u.ID
63
actor = u
64
} else {
65
http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)
66
return
67
53
}
68
54
var req releaseRequest
69
if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&req); err != nil {
70
http.Error(w, s.tr(r, "err.json"), http.StatusBadRequest)
71
return
72
}
73
if err := names.ValidTag(req.Tag); err != nil {
74
http.Error(w, s.trErr(r, err), http.StatusBadRequest)
75
return
76
}
77
if !safeSHA(req.Commit) {
78
http.Error(w, s.tr(r, "err.commitAbsent"), http.StatusBadRequest)
79
return
80
}
81
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
82
if !gitrepo.HasCommit(r.Context(), s.Git, dir, req.Commit) {
83
http.Error(w, s.tr(r, "err.commitMissing"), http.StatusBadRequest)
84
return
85
}
86
if req.Name == "" {
87
req.Name = req.Tag
88
}
89
if job.ID == 0 && len(req.Assets) > 0 {
90
http.Error(w, s.tr(r, "err.assetsJob"), http.StatusBadRequest)
55
if err := readJSON(r, &req); err != nil {
56
s.writeAPIErr(w, r, fail(http.StatusBadRequest, i18n.E("err.json")))
91
57
return
92
58
}
93
var assets []store.ReleaseAsset
94
for _, a := range req.Assets {
95
if a.Name == "" {
96
a.Name = filepath.Base(a.Path)
97
}
98
if err := names.ValidRepoName(strings.ReplaceAll(a.Name, ".", "x")); err != nil && strings.Contains(a.Name, "..") {
99
http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest)
100
return
101
}
102
if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" {
103
http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest)
104
return
105
}
106
src, err := s.Store.ArtifactPath(r.Context(), job.PipelineID, a.Job, a.Path)
107
if err != nil {
108
http.Error(w, s.tr(r, "err.artifactMissing", a.Job, a.Path), http.StatusBadRequest)
109
return
110
}
111
info, err := os.Stat(src)
112
if err != nil {
113
http.Error(w, s.tr(r, "err.assetDisk"), http.StatusBadRequest)
114
return
115
}
116
dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name)
117
if err := copyRelease(src, dst); err != nil {
118
http.Error(w, s.tr(r, "err.assetCopy"), http.StatusInternalServerError)
119
return
120
}
121
assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: info.Size()})
122
}
123
if err := s.postReceive(r.Context(), repo, actor, dir, func() error {
124
return gitrepo.Tag(r.Context(), s.Git, dir, req.Tag, req.Commit, req.Name)
125
}); err != nil {
126
http.Error(w, s.tr(r, "err.tagFail", err.Error()), http.StatusBadRequest)
127
return
128
}
129
id, err := s.Store.CreateRelease(r.Context(), repo.ID, req.Tag, req.Commit, req.Name, req.Body, author, job.ID, assets)
130
if err != nil {
131
http.Error(w, s.trErr(r, err), http.StatusBadRequest)
59
id, err := s.opPublishRelease(r.Context(), repo, author, job, req)
60
if !s.apiOK(w, r, err) {
132
61
return
133
62
}
134
s.Dispatch(repo.ID, webhook.Event{
135
Type: webhook.EventRelease, Project: repo.FullPath(), Commit: req.Commit,
136
ReleaseTag: req.Tag, Summary: i18n.T(i18n.EN, "hook.release", req.Tag, repo.FullPath()),
137
URL: strings.TrimRight(s.Cfg.BaseURL, "/") + repoURL(repo) + "/-/releases",
138
})
139
w.Header().Set("Content-Type", "application/json")
140
w.WriteHeader(http.StatusCreated)
141
_ = json.NewEncoder(w).Encode(map[string]any{"id": id, "tag": req.Tag, "commit": req.Commit})
63
writeJSON(w, http.StatusCreated, map[string]any{"id": id, "tag": req.Tag, "commit": req.Commit})
142
64
}
143
65
144
66
func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) {
@@ -1,7 +1,6 @@1
package server1
package server2
2
3
import (3
import (4
"encoding/json"5
"io"4
"io"6
"net/http"5
"net/http"7
"os"6
"os"@@ -9,11 +8,8 @@ import (9
"strings"8
"strings"10
9
11
"gitlab.com/Timfa/bluegit/internal/access"10
"gitlab.com/Timfa/bluegit/internal/access"12
"gitlab.com/Timfa/bluegit/internal/gitrepo"13
"gitlab.com/Timfa/bluegit/internal/i18n"11
"gitlab.com/Timfa/bluegit/internal/i18n"14
"gitlab.com/Timfa/bluegit/internal/names"15
"gitlab.com/Timfa/bluegit/internal/store"12
"gitlab.com/Timfa/bluegit/internal/store"16
"gitlab.com/Timfa/bluegit/internal/webhook"17
)13
)18
14
19
type releaseRequest struct {15
type releaseRequest struct {@@ -29,116 +25,42 @@ type releaseRequest struct {29
}25
}30
26
31
func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) {27
func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) {32
if s.StoragePath() == "" {33
http.Error(w, s.noStorageText(r), http.StatusServiceUnavailable)34
return35
}36
repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))28
repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))37
if err != nil {29
if err != nil {38
http.NotFound(w, r)30
s.writeAPIErr(w, r, fail(http.StatusNotFound, i18n.E("err.notFound")))39
return31
return40
}32
}41
token := bearer(r)33
token := tokenFrom(r)42
var job store.Job34
var job store.Job43
var author int6435
var author store.User44
var actor store.User45
if strings.HasPrefix(token, "bgj_") {36
if strings.HasPrefix(token, "bgj_") {46
job, err = s.Store.JobByToken(r.Context(), token)37
job, err = s.Store.JobByToken(r.Context(), token)47
if err != nil || job.RepoID != repo.ID || job.Status != "running" {38
if err != nil || job.RepoID != repo.ID || job.Status != "running" {48
http.Error(w, s.tr(r, "err.jobToken"), http.StatusUnauthorized)39
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.jobToken")))49
return40
return50
}41
}51
} else if strings.HasPrefix(token, "bg_") {42
} else {52
u, err := s.Store.UserByToken(r.Context(), token)43
author = apiUser(r)53
if err != nil {44
if author.ID == 0 {54
http.Error(w, s.tr(r, "err.tokenBad"), http.StatusUnauthorized)45
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.apiAuth")))55
return46
return56
}47
}57
role, err := s.Store.EffectiveRole(r.Context(), u.ID, repo.ID)48
role, err := s.Store.EffectiveRole(r.Context(), author.ID, repo.ID)58
if err != nil || !role.AtLeast(access.RoleMaintainer) {49
if err != nil || !role.AtLeast(access.RoleMaintainer) {59
http.Error(w, s.tr(r, "err.onlyAdmin"), http.StatusForbidden)50
s.writeAPIErr(w, r, fail(http.StatusForbidden, i18n.E("err.onlyAdmin")))60
return51
return61
}52
}62
author = u.ID63
actor = u64
} else {65
http.Error(w, s.tr(r, "err.tokenAbsent"), http.StatusUnauthorized)66
return67
}53
}68
var req releaseRequest54
var req releaseRequest69
if err := json.NewDecoder(io.LimitReader(r.Body, 1<<20)).Decode(&req); err != nil {55
if err := readJSON(r, &req); err != nil {70
http.Error(w, s.tr(r, "err.json"), http.StatusBadRequest)56
s.writeAPIErr(w, r, fail(http.StatusBadRequest, i18n.E("err.json")))71
return72
}73
if err := names.ValidTag(req.Tag); err != nil {74
http.Error(w, s.trErr(r, err), http.StatusBadRequest)75
return76
}77
if !safeSHA(req.Commit) {78
http.Error(w, s.tr(r, "err.commitAbsent"), http.StatusBadRequest)79
return80
}81
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)82
if !gitrepo.HasCommit(r.Context(), s.Git, dir, req.Commit) {83
http.Error(w, s.tr(r, "err.commitMissing"), http.StatusBadRequest)84
return85
}86
if req.Name == "" {87
req.Name = req.Tag88
}89
if job.ID == 0 && len(req.Assets) > 0 {90
http.Error(w, s.tr(r, "err.assetsJob"), http.StatusBadRequest)91
return57
return92
}58
}93
var assets []store.ReleaseAsset59
id, err := s.opPublishRelease(r.Context(), repo, author, job, req)94
for _, a := range req.Assets {60
if !s.apiOK(w, r, err) {95
if a.Name == "" {96
a.Name = filepath.Base(a.Path)97
}98
if err := names.ValidRepoName(strings.ReplaceAll(a.Name, ".", "x")); err != nil && strings.Contains(a.Name, "..") {99
http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest)100
return101
}102
if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" {103
http.Error(w, s.tr(r, "err.assetName"), http.StatusBadRequest)104
return105
}106
src, err := s.Store.ArtifactPath(r.Context(), job.PipelineID, a.Job, a.Path)107
if err != nil {108
http.Error(w, s.tr(r, "err.artifactMissing", a.Job, a.Path), http.StatusBadRequest)109
return110
}111
info, err := os.Stat(src)112
if err != nil {113
http.Error(w, s.tr(r, "err.assetDisk"), http.StatusBadRequest)114
return115
}116
dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name)117
if err := copyRelease(src, dst); err != nil {118
http.Error(w, s.tr(r, "err.assetCopy"), http.StatusInternalServerError)119
return120
}121
assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: info.Size()})122
}123
if err := s.postReceive(r.Context(), repo, actor, dir, func() error {124
return gitrepo.Tag(r.Context(), s.Git, dir, req.Tag, req.Commit, req.Name)125
}); err != nil {126
http.Error(w, s.tr(r, "err.tagFail", err.Error()), http.StatusBadRequest)127
return128
}129
id, err := s.Store.CreateRelease(r.Context(), repo.ID, req.Tag, req.Commit, req.Name, req.Body, author, job.ID, assets)130
if err != nil {131
http.Error(w, s.trErr(r, err), http.StatusBadRequest)132
return61
return133
}62
}134
s.Dispatch(repo.ID, webhook.Event{63
writeJSON(w, http.StatusCreated, map[string]any{"id": id, "tag": req.Tag, "commit": req.Commit})135
Type: webhook.EventRelease, Project: repo.FullPath(), Commit: req.Commit,136
ReleaseTag: req.Tag, Summary: i18n.T(i18n.EN, "hook.release", req.Tag, repo.FullPath()),137
URL: strings.TrimRight(s.Cfg.BaseURL, "/") + repoURL(repo) + "/-/releases",138
})139
w.Header().Set("Content-Type", "application/json")140
w.WriteHeader(http.StatusCreated)141
_ = json.NewEncoder(w).Encode(map[string]any{"id": id, "tag": req.Tag, "commit": req.Commit})142
}64
}143
65
144
func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) {66
func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) {@@ -0,0 +1,198 @@
1
package server
2
3
import (
4
"net/http"
5
"strconv"
6
"time"
7
8
"gitlab.com/Timfa/bluegit/internal/access"
9
"gitlab.com/Timfa/bluegit/internal/i18n"
10
"gitlab.com/Timfa/bluegit/internal/store"
11
)
12
13
func rfcTime(t time.Time) any {
14
if t.IsZero() {
15
return nil
16
}
17
return t.UTC().Format(time.RFC3339)
18
}
19
20
func userJSON(u store.User, self bool) map[string]any {
21
out := map[string]any{
22
"id": u.ID, "username": u.Username, "avatar_url": u.AvatarURL,
23
}
24
if self {
25
out["instance_admin"] = u.InstanceAdmin
26
out["language"] = u.Language
27
}
28
return out
29
}
30
31
func tokenJSON(t store.TokenInfo, plain string) map[string]any {
32
out := map[string]any{
33
"id": t.ID, "name": t.Name, "prefix": t.Prefix,
34
"scopes": access.StoredScopes(t.Scopes).List(),
35
"created_at": rfcTime(t.CreatedAt),
36
"last_used_at": rfcTime(t.LastUsedAt),
37
"expires_at": rfcTime(t.ExpiresAt),
38
}
39
if plain != "" {
40
out["token"] = plain
41
}
42
return out
43
}
44
45
func (s *Server) apiGetUser(w http.ResponseWriter, r *http.Request) {
46
writeJSON(w, http.StatusOK, userJSON(apiUser(r), true))
47
}
48
49
func (s *Server) apiPutUser(w http.ResponseWriter, r *http.Request) {
50
var in struct {
51
Language string `json:"language"`
52
}
53
if err := readJSON(r, &in); err != nil {
54
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
55
return
56
}
57
lang, err := s.opSetLanguage(r.Context(), apiUser(r), in.Language)
58
if !s.apiOK(w, r, err) {
59
return
60
}
61
u := apiUser(r)
62
u.Language = string(lang)
63
writeJSON(w, http.StatusOK, userJSON(u, true))
64
}
65
66
func (s *Server) apiExport(w http.ResponseWriter, r *http.Request) {
67
writeJSON(w, http.StatusOK, s.opExport(r.Context(), apiUser(r)))
68
}
69
70
func (s *Server) apiUserByName(w http.ResponseWriter, r *http.Request) {
71
u, err := s.Store.UserByUsername(r.Context(), r.PathValue("username"))
72
if err != nil {
73
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
74
return
75
}
76
writeJSON(w, http.StatusOK, userJSON(u, false))
77
}
78
79
func (s *Server) apiListTokens(w http.ResponseWriter, r *http.Request) {
80
list, err := s.Store.ListTokens(r.Context(), apiUser(r).ID)
81
if !s.apiOK(w, r, err) {
82
return
83
}
84
page, per := pageQuery(r)
85
rows := make([]map[string]any, 0, len(list))
86
for _, t := range list {
87
rows = append(rows, tokenJSON(t, ""))
88
}
89
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
90
}
91
92
func (s *Server) apiCreateToken(w http.ResponseWriter, r *http.Request) {
93
var in struct {
94
Name string `json:"name"`
95
Scopes []string `json:"scopes"`
96
ExpiresAt string `json:"expires_at"`
97
}
98
if err := readJSON(r, &in); err != nil {
99
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
100
return
101
}
102
var exp time.Time
103
if in.ExpiresAt != "" {
104
parsed, err := time.Parse(time.RFC3339, in.ExpiresAt)
105
if err != nil {
106
s.writeAPIErr(w, r, fail(400, i18n.E("err.tokenExpired")))
107
return
108
}
109
exp = parsed
110
}
111
plain, info, err := s.opIssueToken(r.Context(), apiUser(r), in.Name, in.Scopes, exp)
112
if !s.apiOK(w, r, err) {
113
return
114
}
115
writeJSON(w, http.StatusCreated, tokenJSON(info, plain))
116
}
117
118
func (s *Server) apiDeleteToken(w http.ResponseWriter, r *http.Request) {
119
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
120
if err != nil {
121
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
122
return
123
}
124
if !s.apiOK(w, r, s.opRevokeToken(r.Context(), apiUser(r), id)) {
125
return
126
}
127
writeJSON(w, http.StatusNoContent, nil)
128
}
129
130
func keyJSON(k store.SSHKey) map[string]any {
131
return map[string]any{
132
"id": k.ID, "name": k.Name, "key": k.PublicKey, "fingerprint": k.Fingerprint,
133
"created_at": rfcTime(k.CreatedAt),
134
}
135
}
136
137
func (s *Server) apiListKeys(w http.ResponseWriter, r *http.Request) {
138
list, err := s.Store.ListSSHKeys(r.Context(), apiUser(r).ID)
139
if !s.apiOK(w, r, err) {
140
return
141
}
142
page, per := pageQuery(r)
143
rows := make([]map[string]any, 0, len(list))
144
for _, k := range list {
145
rows = append(rows, keyJSON(k))
146
}
147
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
148
}
149
150
func (s *Server) apiAddKey(w http.ResponseWriter, r *http.Request) {
151
var in struct {
152
Name string `json:"name"`
153
Key string `json:"key"`
154
}
155
if err := readJSON(r, &in); err != nil {
156
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
157
return
158
}
159
if !s.apiOK(w, r, s.opAddSSH(r.Context(), apiUser(r), in.Name, in.Key)) {
160
return
161
}
162
writeJSON(w, http.StatusCreated, map[string]any{"name": in.Name})
163
}
164
165
func (s *Server) apiDeleteKey(w http.ResponseWriter, r *http.Request) {
166
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
167
if err != nil {
168
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
169
return
170
}
171
if !s.apiOK(w, r, s.opRemoveSSH(r.Context(), apiUser(r), id)) {
172
return
173
}
174
writeJSON(w, http.StatusNoContent, nil)
175
}
176
177
func (s *Server) apiAdminStorage(w http.ResponseWriter, r *http.Request) {
178
if !apiUser(r).InstanceAdmin {
179
s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
180
return
181
}
182
if r.Method == http.MethodGet {
183
writeJSON(w, http.StatusOK, map[string]any{"path": s.StoragePath()})
184
return
185
}
186
var in struct {
187
Path string `json:"path"`
188
}
189
if err := readJSON(r, &in); err != nil {
190
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
191
return
192
}
193
info, moved, err := s.opSetStorage(in.Path)
194
if !s.apiOK(w, r, err) {
195
return
196
}
197
writeJSON(w, http.StatusOK, map[string]any{"path": info.Path, "moved": moved, "free": info.Free})
198
}
@@ -0,0 +1,198 @@1
package server2
3
import (4
"net/http"5
"strconv"6
"time"7
8
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/i18n"10
"gitlab.com/Timfa/bluegit/internal/store"11
)12
13
func rfcTime(t time.Time) any {14
if t.IsZero() {15
return nil16
}17
return t.UTC().Format(time.RFC3339)18
}19
20
func userJSON(u store.User, self bool) map[string]any {21
out := map[string]any{22
"id": u.ID, "username": u.Username, "avatar_url": u.AvatarURL,23
}24
if self {25
out["instance_admin"] = u.InstanceAdmin26
out["language"] = u.Language27
}28
return out29
}30
31
func tokenJSON(t store.TokenInfo, plain string) map[string]any {32
out := map[string]any{33
"id": t.ID, "name": t.Name, "prefix": t.Prefix,34
"scopes": access.StoredScopes(t.Scopes).List(),35
"created_at": rfcTime(t.CreatedAt),36
"last_used_at": rfcTime(t.LastUsedAt),37
"expires_at": rfcTime(t.ExpiresAt),38
}39
if plain != "" {40
out["token"] = plain41
}42
return out43
}44
45
func (s *Server) apiGetUser(w http.ResponseWriter, r *http.Request) {46
writeJSON(w, http.StatusOK, userJSON(apiUser(r), true))47
}48
49
func (s *Server) apiPutUser(w http.ResponseWriter, r *http.Request) {50
var in struct {51
Language string `json:"language"`52
}53
if err := readJSON(r, &in); err != nil {54
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))55
return56
}57
lang, err := s.opSetLanguage(r.Context(), apiUser(r), in.Language)58
if !s.apiOK(w, r, err) {59
return60
}61
u := apiUser(r)62
u.Language = string(lang)63
writeJSON(w, http.StatusOK, userJSON(u, true))64
}65
66
func (s *Server) apiExport(w http.ResponseWriter, r *http.Request) {67
writeJSON(w, http.StatusOK, s.opExport(r.Context(), apiUser(r)))68
}69
70
func (s *Server) apiUserByName(w http.ResponseWriter, r *http.Request) {71
u, err := s.Store.UserByUsername(r.Context(), r.PathValue("username"))72
if err != nil {73
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))74
return75
}76
writeJSON(w, http.StatusOK, userJSON(u, false))77
}78
79
func (s *Server) apiListTokens(w http.ResponseWriter, r *http.Request) {80
list, err := s.Store.ListTokens(r.Context(), apiUser(r).ID)81
if !s.apiOK(w, r, err) {82
return83
}84
page, per := pageQuery(r)85
rows := make([]map[string]any, 0, len(list))86
for _, t := range list {87
rows = append(rows, tokenJSON(t, ""))88
}89
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)90
}91
92
func (s *Server) apiCreateToken(w http.ResponseWriter, r *http.Request) {93
var in struct {94
Name string `json:"name"`95
Scopes []string `json:"scopes"`96
ExpiresAt string `json:"expires_at"`97
}98
if err := readJSON(r, &in); err != nil {99
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))100
return101
}102
var exp time.Time103
if in.ExpiresAt != "" {104
parsed, err := time.Parse(time.RFC3339, in.ExpiresAt)105
if err != nil {106
s.writeAPIErr(w, r, fail(400, i18n.E("err.tokenExpired")))107
return108
}109
exp = parsed110
}111
plain, info, err := s.opIssueToken(r.Context(), apiUser(r), in.Name, in.Scopes, exp)112
if !s.apiOK(w, r, err) {113
return114
}115
writeJSON(w, http.StatusCreated, tokenJSON(info, plain))116
}117
118
func (s *Server) apiDeleteToken(w http.ResponseWriter, r *http.Request) {119
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)120
if err != nil {121
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))122
return123
}124
if !s.apiOK(w, r, s.opRevokeToken(r.Context(), apiUser(r), id)) {125
return126
}127
writeJSON(w, http.StatusNoContent, nil)128
}129
130
func keyJSON(k store.SSHKey) map[string]any {131
return map[string]any{132
"id": k.ID, "name": k.Name, "key": k.PublicKey, "fingerprint": k.Fingerprint,133
"created_at": rfcTime(k.CreatedAt),134
}135
}136
137
func (s *Server) apiListKeys(w http.ResponseWriter, r *http.Request) {138
list, err := s.Store.ListSSHKeys(r.Context(), apiUser(r).ID)139
if !s.apiOK(w, r, err) {140
return141
}142
page, per := pageQuery(r)143
rows := make([]map[string]any, 0, len(list))144
for _, k := range list {145
rows = append(rows, keyJSON(k))146
}147
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)148
}149
150
func (s *Server) apiAddKey(w http.ResponseWriter, r *http.Request) {151
var in struct {152
Name string `json:"name"`153
Key string `json:"key"`154
}155
if err := readJSON(r, &in); err != nil {156
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))157
return158
}159
if !s.apiOK(w, r, s.opAddSSH(r.Context(), apiUser(r), in.Name, in.Key)) {160
return161
}162
writeJSON(w, http.StatusCreated, map[string]any{"name": in.Name})163
}164
165
func (s *Server) apiDeleteKey(w http.ResponseWriter, r *http.Request) {166
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)167
if err != nil {168
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))169
return170
}171
if !s.apiOK(w, r, s.opRemoveSSH(r.Context(), apiUser(r), id)) {172
return173
}174
writeJSON(w, http.StatusNoContent, nil)175
}176
177
func (s *Server) apiAdminStorage(w http.ResponseWriter, r *http.Request) {178
if !apiUser(r).InstanceAdmin {179
s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))180
return181
}182
if r.Method == http.MethodGet {183
writeJSON(w, http.StatusOK, map[string]any{"path": s.StoragePath()})184
return185
}186
var in struct {187
Path string `json:"path"`188
}189
if err := readJSON(r, &in); err != nil {190
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))191
return192
}193
info, moved, err := s.opSetStorage(in.Path)194
if !s.apiOK(w, r, err) {195
return196
}197
writeJSON(w, http.StatusOK, map[string]any{"path": info.Path, "moved": moved, "free": info.Free})198
}@@ -0,0 +1,726 @@
1
package server
2
3
import (
4
"net/http"
5
"strconv"
6
7
"gitlab.com/Timfa/bluegit/internal/access"
8
"gitlab.com/Timfa/bluegit/internal/i18n"
9
"gitlab.com/Timfa/bluegit/internal/store"
10
"gitlab.com/Timfa/bluegit/internal/webhook"
11
)
12
13
func groupJSON(g store.Group) map[string]any {
14
return map[string]any{
15
"id": g.ID, "name": g.Name, "path": g.Path, "description": g.Description,
16
"visibility": g.Visibility, "default_role": g.DefaultRole,
17
}
18
}
19
20
func projectJSON(repo store.Repo) map[string]any {
21
return map[string]any{
22
"id": repo.ID, "path": repo.FullPath(), "name": repo.Name, "owner": repo.OwnerPath,
23
"description": repo.Description, "visibility": repo.Visibility, "default_branch": repo.DefaultBranch,
24
}
25
}
26
27
func memberJSON(m store.Member) map[string]any {
28
return map[string]any{"user_id": m.UserID, "username": m.Username, "role": m.Role, "pending": m.Pending}
29
}
30
31
func (s *Server) apiListGroups(w http.ResponseWriter, r *http.Request) {
32
list, err := s.Store.ListGroups(r.Context(), apiUser(r).ID)
33
if !s.apiOK(w, r, err) {
34
return
35
}
36
page, per := pageQuery(r)
37
rows := make([]map[string]any, 0, len(list))
38
for _, g := range list {
39
rows = append(rows, groupJSON(g))
40
}
41
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
42
}
43
44
func (s *Server) apiCreateGroup(w http.ResponseWriter, r *http.Request) {
45
var body struct {
46
Name string `json:"name"`
47
Description string `json:"description"`
48
DefaultRole string `json:"default_role"`
49
}
50
if err := readJSON(r, &body); err != nil {
51
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
52
return
53
}
54
g, err := s.opCreateGroup(r.Context(), apiUser(r), body.Name, body.Description, body.DefaultRole)
55
if !s.apiOK(w, r, err) {
56
return
57
}
58
writeJSON(w, http.StatusCreated, groupJSON(g))
59
}
60
61
func (s *Server) apiGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, bool) {
62
g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))
63
if err != nil {
64
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
65
return store.Group{}, false
66
}
67
role, err := s.Store.GroupRole(r.Context(), g.ID, apiUser(r).ID)
68
if err != nil {
69
s.writeAPIErr(w, r, fail(500, err))
70
return store.Group{}, false
71
}
72
if !role.CanRead() && g.Visibility != "public" {
73
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
74
return store.Group{}, false
75
}
76
if min != access.RoleNone && min != access.RoleReadonly && !role.AtLeast(min) {
77
s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
78
return store.Group{}, false
79
}
80
if min == access.RoleReadonly && !role.CanRead() && g.Visibility != "public" {
81
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
82
return store.Group{}, false
83
}
84
return g, true
85
}
86
87
func (s *Server) apiGetGroup(w http.ResponseWriter, r *http.Request) {
88
g, ok := s.apiGroup(w, r, access.RoleReadonly)
89
if !ok {
90
return
91
}
92
writeJSON(w, http.StatusOK, groupJSON(g))
93
}
94
95
func (s *Server) apiPutGroup(w http.ResponseWriter, r *http.Request) {
96
g, ok := s.apiGroup(w, r, access.RoleMaintainer)
97
if !ok {
98
return
99
}
100
var body struct {
101
Description string `json:"description"`
102
Visibility string `json:"visibility"`
103
DefaultRole string `json:"default_role"`
104
}
105
if err := readJSON(r, &body); err != nil {
106
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
107
return
108
}
109
if !s.apiOK(w, r, s.opUpdateGroup(r.Context(), apiUser(r), g, body.Description, body.Visibility, body.DefaultRole)) {
110
return
111
}
112
g, _ = s.Store.GroupByPath(r.Context(), g.Path)
113
writeJSON(w, http.StatusOK, groupJSON(g))
114
}
115
116
func (s *Server) apiTransferGroup(w http.ResponseWriter, r *http.Request) {
117
g, ok := s.apiGroup(w, r, access.RoleMaintainer)
118
if !ok {
119
return
120
}
121
var body struct {
122
Username string `json:"username"`
123
Confirm string `json:"confirm"`
124
}
125
if err := readJSON(r, &body); err != nil {
126
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
127
return
128
}
129
if !s.apiOK(w, r, s.opTransferGroup(r.Context(), apiUser(r), g, body.Username, body.Confirm)) {
130
return
131
}
132
writeJSON(w, http.StatusOK, map[string]any{"path": g.Path, "owner": body.Username})
133
}
134
135
func (s *Server) apiGroupProjects(w http.ResponseWriter, r *http.Request) {
136
g, ok := s.apiGroup(w, r, access.RoleReadonly)
137
if !ok {
138
return
139
}
140
list, err := s.Store.ReposByGroup(r.Context(), g.ID)
141
if !s.apiOK(w, r, err) {
142
return
143
}
144
s.writeProjects(w, r, list)
145
}
146
147
func (s *Server) apiListProjects(w http.ResponseWriter, r *http.Request) {
148
ids, err := s.Store.ListRepoIDs(r.Context(), apiUser(r).ID)
149
if !s.apiOK(w, r, err) {
150
return
151
}
152
list, err := s.Store.ReposByIDs(r.Context(), ids)
153
if !s.apiOK(w, r, err) {
154
return
155
}
156
s.writeProjects(w, r, list)
157
}
158
159
func (s *Server) writeProjects(w http.ResponseWriter, r *http.Request, list []store.Repo) {
160
page, per := pageQuery(r)
161
rows := make([]map[string]any, 0, len(list))
162
for _, repo := range list {
163
rows = append(rows, projectJSON(repo))
164
}
165
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
166
}
167
168
func (s *Server) apiCreateProject(w http.ResponseWriter, r *http.Request) {
169
var body struct {
170
Name string `json:"name"`
171
Description string `json:"description"`
172
Group string `json:"group"`
173
Visibility string `json:"visibility"`
174
Readme bool `json:"initialize_with_readme"`
175
}
176
if err := readJSON(r, &body); err != nil {
177
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
178
return
179
}
180
repo, err := s.opCreateRepo(r.Context(), apiUser(r), body.Name, body.Description, body.Group, body.Visibility, body.Readme)
181
if !s.apiOK(w, r, err) {
182
return
183
}
184
writeJSON(w, http.StatusCreated, projectJSON(repo))
185
}
186
187
func (s *Server) apiRepo(w http.ResponseWriter, r *http.Request, min access.Role) (store.Repo, access.Role, bool) {
188
repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))
189
if err != nil {
190
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
191
return store.Repo{}, "", false
192
}
193
role, err := s.Store.EffectiveRole(r.Context(), apiUser(r).ID, repo.ID)
194
if err != nil {
195
s.writeAPIErr(w, r, fail(500, err))
196
return store.Repo{}, "", false
197
}
198
readable := role.CanRead() || repo.Visibility == "public"
199
if !readable {
200
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
201
return store.Repo{}, "", false
202
}
203
if min.Rank() > access.RoleReadonly.Rank() && !role.AtLeast(min) {
204
s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))
205
return store.Repo{}, "", false
206
}
207
return repo, role, true
208
}
209
210
func (s *Server) apiGetProject(w http.ResponseWriter, r *http.Request) {
211
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
212
if !ok {
213
return
214
}
215
writeJSON(w, http.StatusOK, projectJSON(repo))
216
}
217
218
func (s *Server) apiPutProject(w http.ResponseWriter, r *http.Request) {
219
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
220
if !ok {
221
return
222
}
223
var body struct {
224
Description string `json:"description"`
225
Visibility string `json:"visibility"`
226
}
227
if err := readJSON(r, &body); err != nil {
228
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
229
return
230
}
231
if !s.apiOK(w, r, s.opUpdateRepo(r.Context(), apiUser(r), repo, body.Description, body.Visibility)) {
232
return
233
}
234
repo, _ = s.Store.RepoByPath(r.Context(), repo.OwnerPath, repo.Name)
235
writeJSON(w, http.StatusOK, projectJSON(repo))
236
}
237
238
func (s *Server) apiDeleteProject(w http.ResponseWriter, r *http.Request) {
239
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
240
if !ok {
241
return
242
}
243
var body struct {
244
Confirm string `json:"confirm"`
245
}
246
if err := readJSON(r, &body); err != nil {
247
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
248
return
249
}
250
if !s.apiOK(w, r, s.opDeleteRepo(r.Context(), apiUser(r), repo, body.Confirm)) {
251
return
252
}
253
writeJSON(w, http.StatusNoContent, nil)
254
}
255
256
func (s *Server) apiStar(w http.ResponseWriter, r *http.Request) {
257
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
258
if !ok {
259
return
260
}
261
on, err := s.opToggleStar(r.Context(), apiUser(r), repo)
262
if !s.apiOK(w, r, err) {
263
return
264
}
265
writeJSON(w, http.StatusOK, map[string]any{"starred": on})
266
}
267
268
func (s *Server) apiMembers(w http.ResponseWriter, r *http.Request, kind string, id int64) {
269
if r.Method == http.MethodGet {
270
list, err := s.Store.ListMembers(r.Context(), kind, id)
271
if !s.apiOK(w, r, err) {
272
return
273
}
274
page, per := pageQuery(r)
275
rows := make([]map[string]any, 0, len(list))
276
for _, m := range list {
277
rows = append(rows, memberJSON(m))
278
}
279
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
280
return
281
}
282
var body struct {
283
Username string `json:"username"`
284
Role string `json:"role"`
285
}
286
if err := readJSON(r, &body); err != nil {
287
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
288
return
289
}
290
if !s.apiOK(w, r, s.opSetMember(r.Context(), apiUser(r), kind, id, body.Username, body.Role)) {
291
return
292
}
293
writeJSON(w, http.StatusOK, map[string]any{"username": body.Username, "role": body.Role})
294
}
295
296
func (s *Server) apiGroupMembers(w http.ResponseWriter, r *http.Request) {
297
min := access.RoleReadonly
298
if r.Method != http.MethodGet {
299
min = access.RoleMaintainer
300
}
301
g, ok := s.apiGroup(w, r, min)
302
if !ok {
303
return
304
}
305
s.apiMembers(w, r, "group", g.ID)
306
}
307
308
func (s *Server) apiProjectMembers(w http.ResponseWriter, r *http.Request) {
309
min := access.RoleReadonly
310
if r.Method != http.MethodGet {
311
min = access.RoleMaintainer
312
}
313
repo, _, ok := s.apiRepo(w, r, min)
314
if !ok {
315
return
316
}
317
s.apiMembers(w, r, "repo", repo.ID)
318
}
319
320
func (s *Server) apiDeleteMember(w http.ResponseWriter, r *http.Request, kind string, id int64) {
321
if !s.apiOK(w, r, s.opRemoveMember(r.Context(), apiUser(r), kind, id, r.PathValue("username"))) {
322
return
323
}
324
writeJSON(w, http.StatusNoContent, nil)
325
}
326
327
func (s *Server) apiDeleteGroupMember(w http.ResponseWriter, r *http.Request) {
328
g, ok := s.apiGroup(w, r, access.RoleMaintainer)
329
if !ok {
330
return
331
}
332
s.apiDeleteMember(w, r, "group", g.ID)
333
}
334
335
func (s *Server) apiDeleteProjectMember(w http.ResponseWriter, r *http.Request) {
336
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
337
if !ok {
338
return
339
}
340
s.apiDeleteMember(w, r, "repo", repo.ID)
341
}
342
343
func secretJSON(m store.SecretMeta) map[string]any {
344
return map[string]any{"name": m.Name, "protected": m.Protected, "created_at": rfcTime(m.CreatedAt)}
345
}
346
347
func (s *Server) apiSecrets(w http.ResponseWriter, r *http.Request, kind string, id int64) {
348
if r.Method == http.MethodGet {
349
list, err := s.Store.ListSecrets(r.Context(), kind, id)
350
if !s.apiOK(w, r, err) {
351
return
352
}
353
rows := make([]map[string]any, 0, len(list))
354
for _, m := range list {
355
rows = append(rows, secretJSON(m))
356
}
357
page, per := pageQuery(r)
358
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
359
return
360
}
361
var body struct {
362
Name string `json:"name"`
363
Value string `json:"value"`
364
Protected bool `json:"protected"`
365
}
366
if err := readJSON(r, &body); err != nil {
367
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
368
return
369
}
370
if !s.apiOK(w, r, s.opPutSecret(r.Context(), apiUser(r), kind, id, body.Name, body.Value, body.Protected)) {
371
return
372
}
373
writeJSON(w, http.StatusOK, map[string]any{"name": body.Name})
374
}
375
376
func (s *Server) apiGroupSecrets(w http.ResponseWriter, r *http.Request) {
377
min := access.RoleReadonly
378
if r.Method != http.MethodGet {
379
min = access.RoleMaintainer
380
}
381
g, ok := s.apiGroup(w, r, min)
382
if !ok {
383
return
384
}
385
if r.Method == http.MethodGet {
386
if err := s.manageScope(r.Context(), apiUser(r), "group", g.ID); err != nil {
387
s.writeAPIErr(w, r, err)
388
return
389
}
390
}
391
s.apiSecrets(w, r, "group", g.ID)
392
}
393
394
func (s *Server) apiProjectSecrets(w http.ResponseWriter, r *http.Request) {
395
min := access.RoleReadonly
396
if r.Method != http.MethodGet {
397
min = access.RoleMaintainer
398
}
399
repo, _, ok := s.apiRepo(w, r, min)
400
if !ok {
401
return
402
}
403
if r.Method == http.MethodGet {
404
if err := s.manageScope(r.Context(), apiUser(r), "repo", repo.ID); err != nil {
405
s.writeAPIErr(w, r, err)
406
return
407
}
408
}
409
s.apiSecrets(w, r, "repo", repo.ID)
410
}
411
412
func (s *Server) apiDeleteSecret(w http.ResponseWriter, r *http.Request, kind string, id int64) {
413
if !s.apiOK(w, r, s.opDeleteSecret(r.Context(), apiUser(r), kind, id, r.PathValue("name"))) {
414
return
415
}
416
writeJSON(w, http.StatusNoContent, nil)
417
}
418
419
func (s *Server) apiDeleteGroupSecret(w http.ResponseWriter, r *http.Request) {
420
g, ok := s.apiGroup(w, r, access.RoleMaintainer)
421
if !ok {
422
return
423
}
424
s.apiDeleteSecret(w, r, "group", g.ID)
425
}
426
427
func (s *Server) apiDeleteProjectSecret(w http.ResponseWriter, r *http.Request) {
428
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
429
if !ok {
430
return
431
}
432
s.apiDeleteSecret(w, r, "repo", repo.ID)
433
}
434
435
func hookJSON(h store.Webhook) map[string]any {
436
return map[string]any{
437
"id": h.ID, "name": h.Name, "preset": h.Preset, "url": h.URLTemplate,
438
"method": h.Method, "events": h.Events, "branch_filter": h.BranchFilter, "active": h.Active,
439
}
440
}
441
442
func (s *Server) apiHooks(w http.ResponseWriter, r *http.Request, kind string, id int64) {
443
if r.Method == http.MethodGet {
444
list, err := s.Store.ListWebhooks(r.Context(), kind, id)
445
if !s.apiOK(w, r, err) {
446
return
447
}
448
rows := make([]map[string]any, 0, len(list))
449
for _, h := range list {
450
rows = append(rows, hookJSON(h))
451
}
452
page, per := pageQuery(r)
453
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
454
return
455
}
456
var body struct {
457
Name string `json:"name"`
458
Preset string `json:"preset"`
459
BranchFilter string `json:"branch_filter"`
460
Events []string `json:"events"`
461
URL string `json:"url"`
462
Username string `json:"username"`
463
Avatar string `json:"avatar"`
464
Icon string `json:"icon"`
465
Alias string `json:"alias"`
466
Token string `json:"token"`
467
Chat string `json:"chat"`
468
Server string `json:"server"`
469
Topic string `json:"topic"`
470
Homeserver string `json:"homeserver"`
471
Room string `json:"room"`
472
Method string `json:"method"`
473
ContentType string `json:"content_type"`
474
Headers string `json:"headers"`
475
Body string `json:"body"`
476
}
477
if err := readJSON(r, &body); err != nil {
478
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
479
return
480
}
481
wid, err := s.opCreateWebhook(r.Context(), apiUser(r), kind, id, hookIn{
482
Name: body.Name, Preset: body.Preset, Filter: body.BranchFilter, Events: body.Events,
483
Fields: webhook.Input{
484
URL: body.URL, Username: body.Username, Avatar: body.Avatar, Icon: body.Icon, Alias: body.Alias,
485
Token: body.Token, Chat: body.Chat, Server: body.Server, Topic: body.Topic,
486
Homeserver: body.Homeserver, Room: body.Room, Method: body.Method, ContentType: body.ContentType,
487
Headers: body.Headers, Body: body.Body,
488
},
489
})
490
if !s.apiOK(w, r, err) {
491
return
492
}
493
writeJSON(w, http.StatusCreated, map[string]any{"id": wid})
494
}
495
496
func (s *Server) apiGroupHooks(w http.ResponseWriter, r *http.Request) {
497
g, ok := s.apiGroup(w, r, access.RoleMaintainer)
498
if !ok {
499
return
500
}
501
s.apiHooks(w, r, "group", g.ID)
502
}
503
504
func (s *Server) apiProjectHooks(w http.ResponseWriter, r *http.Request) {
505
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
506
if !ok {
507
return
508
}
509
s.apiHooks(w, r, "repo", repo.ID)
510
}
511
512
func (s *Server) apiDeleteHook(w http.ResponseWriter, r *http.Request, kind string, id int64) {
513
hid, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
514
if err != nil {
515
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
516
return
517
}
518
if !s.apiOK(w, r, s.opDeleteWebhook(r.Context(), apiUser(r), kind, id, hid)) {
519
return
520
}
521
writeJSON(w, http.StatusNoContent, nil)
522
}
523
524
func (s *Server) apiDeleteGroupHook(w http.ResponseWriter, r *http.Request) {
525
g, ok := s.apiGroup(w, r, access.RoleMaintainer)
526
if !ok {
527
return
528
}
529
s.apiDeleteHook(w, r, "group", g.ID)
530
}
531
532
func (s *Server) apiDeleteProjectHook(w http.ResponseWriter, r *http.Request) {
533
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
534
if !ok {
535
return
536
}
537
s.apiDeleteHook(w, r, "repo", repo.ID)
538
}
539
540
func approvalJSON(p store.ApprovalPolicy, locked string) map[string]any {
541
return map[string]any{
542
"configured": p.Configured, "maintainer_required": p.MaintainerRequired,
543
"required_count": p.RequiredCount, "developers_approve": p.DevelopersApprove,
544
"locked_by": locked,
545
}
546
}
547
548
func approvalBody(r *http.Request) (store.ApprovalPolicy, error) {
549
var body struct {
550
MaintainerRequired bool `json:"maintainer_required"`
551
RequiredCount int `json:"required_count"`
552
DevelopersApprove bool `json:"developers_approve"`
553
}
554
if err := readJSON(r, &body); err != nil {
555
return store.ApprovalPolicy{}, fail(400, i18n.E("err.json"))
556
}
557
return store.ApprovalPolicy{
558
MaintainerRequired: body.MaintainerRequired,
559
RequiredCount: body.RequiredCount,
560
DevelopersApprove: body.DevelopersApprove,
561
}, nil
562
}
563
564
func (s *Server) apiGroupApproval(w http.ResponseWriter, r *http.Request) {
565
min := access.RoleReadonly
566
if r.Method != http.MethodGet {
567
min = access.RoleMaintainer
568
}
569
g, ok := s.apiGroup(w, r, min)
570
if !ok {
571
return
572
}
573
if r.Method == http.MethodGet {
574
p, err := s.Store.GetApproval(r.Context(), "group", g.ID)
575
if !s.apiOK(w, r, err) {
576
return
577
}
578
writeJSON(w, http.StatusOK, approvalJSON(p, ""))
579
return
580
}
581
pol, err := approvalBody(r)
582
if !s.apiOK(w, r, err) {
583
return
584
}
585
if !s.apiOK(w, r, s.opSaveGroupApproval(r.Context(), apiUser(r), g, pol)) {
586
return
587
}
588
writeJSON(w, http.StatusOK, approvalJSON(pol, ""))
589
}
590
591
func (s *Server) apiProjectApproval(w http.ResponseWriter, r *http.Request) {
592
min := access.RoleReadonly
593
if r.Method != http.MethodGet {
594
min = access.RoleMaintainer
595
}
596
repo, _, ok := s.apiRepo(w, r, min)
597
if !ok {
598
return
599
}
600
pol, locked, err := s.Store.EffectiveApproval(r.Context(), repo)
601
if !s.apiOK(w, r, err) {
602
return
603
}
604
if r.Method == http.MethodGet {
605
writeJSON(w, http.StatusOK, approvalJSON(pol, locked))
606
return
607
}
608
next, err := approvalBody(r)
609
if !s.apiOK(w, r, err) {
610
return
611
}
612
if !s.apiOK(w, r, s.opSaveRepoApproval(r.Context(), apiUser(r), repo, next)) {
613
return
614
}
615
writeJSON(w, http.StatusOK, approvalJSON(next, ""))
616
}
617
618
func (s *Server) apiLogo(w http.ResponseWriter, r *http.Request, kind string, id int64, mime string) {
619
if r.Method == http.MethodGet {
620
s.serveLogo(w, r, kind, id, mime)
621
return
622
}
623
if err := r.ParseMultipartForm(2 << 20); err != nil {
624
s.writeAPIErr(w, r, fail(400, i18n.E("err.badForm")))
625
return
626
}
627
if err := s.storeLogo(r, kind, id); err != nil {
628
s.writeAPIErr(w, r, fail(400, err))
629
return
630
}
631
writeJSON(w, http.StatusOK, map[string]any{"logo": true})
632
}
633
634
func (s *Server) apiGroupLogo(w http.ResponseWriter, r *http.Request) {
635
min := access.RoleReadonly
636
if r.Method != http.MethodGet {
637
min = access.RoleMaintainer
638
}
639
g, ok := s.apiGroup(w, r, min)
640
if !ok {
641
return
642
}
643
s.apiLogo(w, r, "group", g.ID, g.LogoMIME)
644
}
645
646
func (s *Server) apiProjectLogo(w http.ResponseWriter, r *http.Request) {
647
min := access.RoleReadonly
648
if r.Method != http.MethodGet {
649
min = access.RoleMaintainer
650
}
651
repo, _, ok := s.apiRepo(w, r, min)
652
if !ok {
653
return
654
}
655
s.apiLogo(w, r, "repo", repo.ID, repo.LogoMIME)
656
}
657
658
func (s *Server) apiPatterns(w http.ResponseWriter, r *http.Request, tag bool) {
659
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
660
if !ok {
661
return
662
}
663
if r.Method == http.MethodGet {
664
var list []string
665
var err error
666
if tag {
667
list, err = s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
668
} else {
669
list, err = s.Store.ProtectedPatterns(r.Context(), repo.ID)
670
}
671
if !s.apiOK(w, r, err) {
672
return
673
}
674
if list == nil {
675
list = []string{}
676
}
677
writeJSON(w, http.StatusOK, list)
678
return
679
}
680
if _, _, ok := s.apiRepo(w, r, access.RoleMaintainer); !ok {
681
return
682
}
683
var body struct {
684
Pattern string `json:"pattern"`
685
}
686
if err := readJSON(r, &body); err != nil {
687
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
688
return
689
}
690
if !s.apiOK(w, r, s.opProtect(r.Context(), apiUser(r), repo, body.Pattern, tag)) {
691
return
692
}
693
writeJSON(w, http.StatusCreated, map[string]any{"pattern": body.Pattern})
694
}
695
696
func (s *Server) apiProtectBranches(w http.ResponseWriter, r *http.Request) {
697
s.apiPatterns(w, r, false)
698
}
699
700
func (s *Server) apiProtectTags(w http.ResponseWriter, r *http.Request) {
701
s.apiPatterns(w, r, true)
702
}
703
704
func (s *Server) apiUnprotect(w http.ResponseWriter, r *http.Request, tag bool) {
705
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
706
if !ok {
707
return
708
}
709
name := "pattern"
710
if tag {
711
name = "pattern"
712
}
713
pattern := r.PathValue(name)
714
if !s.apiOK(w, r, s.opUnprotect(r.Context(), apiUser(r), repo, pattern, tag)) {
715
return
716
}
717
writeJSON(w, http.StatusNoContent, nil)
718
}
719
720
func (s *Server) apiUnprotectBranch(w http.ResponseWriter, r *http.Request) {
721
s.apiUnprotect(w, r, false)
722
}
723
724
func (s *Server) apiUnprotectTag(w http.ResponseWriter, r *http.Request) {
725
s.apiUnprotect(w, r, true)
726
}
@@ -0,0 +1,726 @@1
package server2
3
import (4
"net/http"5
"strconv"6
7
"gitlab.com/Timfa/bluegit/internal/access"8
"gitlab.com/Timfa/bluegit/internal/i18n"9
"gitlab.com/Timfa/bluegit/internal/store"10
"gitlab.com/Timfa/bluegit/internal/webhook"11
)12
13
func groupJSON(g store.Group) map[string]any {14
return map[string]any{15
"id": g.ID, "name": g.Name, "path": g.Path, "description": g.Description,16
"visibility": g.Visibility, "default_role": g.DefaultRole,17
}18
}19
20
func projectJSON(repo store.Repo) map[string]any {21
return map[string]any{22
"id": repo.ID, "path": repo.FullPath(), "name": repo.Name, "owner": repo.OwnerPath,23
"description": repo.Description, "visibility": repo.Visibility, "default_branch": repo.DefaultBranch,24
}25
}26
27
func memberJSON(m store.Member) map[string]any {28
return map[string]any{"user_id": m.UserID, "username": m.Username, "role": m.Role, "pending": m.Pending}29
}30
31
func (s *Server) apiListGroups(w http.ResponseWriter, r *http.Request) {32
list, err := s.Store.ListGroups(r.Context(), apiUser(r).ID)33
if !s.apiOK(w, r, err) {34
return35
}36
page, per := pageQuery(r)37
rows := make([]map[string]any, 0, len(list))38
for _, g := range list {39
rows = append(rows, groupJSON(g))40
}41
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)42
}43
44
func (s *Server) apiCreateGroup(w http.ResponseWriter, r *http.Request) {45
var body struct {46
Name string `json:"name"`47
Description string `json:"description"`48
DefaultRole string `json:"default_role"`49
}50
if err := readJSON(r, &body); err != nil {51
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))52
return53
}54
g, err := s.opCreateGroup(r.Context(), apiUser(r), body.Name, body.Description, body.DefaultRole)55
if !s.apiOK(w, r, err) {56
return57
}58
writeJSON(w, http.StatusCreated, groupJSON(g))59
}60
61
func (s *Server) apiGroup(w http.ResponseWriter, r *http.Request, min access.Role) (store.Group, bool) {62
g, err := s.Store.GroupByPath(r.Context(), r.PathValue("path"))63
if err != nil {64
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))65
return store.Group{}, false66
}67
role, err := s.Store.GroupRole(r.Context(), g.ID, apiUser(r).ID)68
if err != nil {69
s.writeAPIErr(w, r, fail(500, err))70
return store.Group{}, false71
}72
if !role.CanRead() && g.Visibility != "public" {73
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))74
return store.Group{}, false75
}76
if min != access.RoleNone && min != access.RoleReadonly && !role.AtLeast(min) {77
s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))78
return store.Group{}, false79
}80
if min == access.RoleReadonly && !role.CanRead() && g.Visibility != "public" {81
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))82
return store.Group{}, false83
}84
return g, true85
}86
87
func (s *Server) apiGetGroup(w http.ResponseWriter, r *http.Request) {88
g, ok := s.apiGroup(w, r, access.RoleReadonly)89
if !ok {90
return91
}92
writeJSON(w, http.StatusOK, groupJSON(g))93
}94
95
func (s *Server) apiPutGroup(w http.ResponseWriter, r *http.Request) {96
g, ok := s.apiGroup(w, r, access.RoleMaintainer)97
if !ok {98
return99
}100
var body struct {101
Description string `json:"description"`102
Visibility string `json:"visibility"`103
DefaultRole string `json:"default_role"`104
}105
if err := readJSON(r, &body); err != nil {106
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))107
return108
}109
if !s.apiOK(w, r, s.opUpdateGroup(r.Context(), apiUser(r), g, body.Description, body.Visibility, body.DefaultRole)) {110
return111
}112
g, _ = s.Store.GroupByPath(r.Context(), g.Path)113
writeJSON(w, http.StatusOK, groupJSON(g))114
}115
116
func (s *Server) apiTransferGroup(w http.ResponseWriter, r *http.Request) {117
g, ok := s.apiGroup(w, r, access.RoleMaintainer)118
if !ok {119
return120
}121
var body struct {122
Username string `json:"username"`123
Confirm string `json:"confirm"`124
}125
if err := readJSON(r, &body); err != nil {126
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))127
return128
}129
if !s.apiOK(w, r, s.opTransferGroup(r.Context(), apiUser(r), g, body.Username, body.Confirm)) {130
return131
}132
writeJSON(w, http.StatusOK, map[string]any{"path": g.Path, "owner": body.Username})133
}134
135
func (s *Server) apiGroupProjects(w http.ResponseWriter, r *http.Request) {136
g, ok := s.apiGroup(w, r, access.RoleReadonly)137
if !ok {138
return139
}140
list, err := s.Store.ReposByGroup(r.Context(), g.ID)141
if !s.apiOK(w, r, err) {142
return143
}144
s.writeProjects(w, r, list)145
}146
147
func (s *Server) apiListProjects(w http.ResponseWriter, r *http.Request) {148
ids, err := s.Store.ListRepoIDs(r.Context(), apiUser(r).ID)149
if !s.apiOK(w, r, err) {150
return151
}152
list, err := s.Store.ReposByIDs(r.Context(), ids)153
if !s.apiOK(w, r, err) {154
return155
}156
s.writeProjects(w, r, list)157
}158
159
func (s *Server) writeProjects(w http.ResponseWriter, r *http.Request, list []store.Repo) {160
page, per := pageQuery(r)161
rows := make([]map[string]any, 0, len(list))162
for _, repo := range list {163
rows = append(rows, projectJSON(repo))164
}165
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)166
}167
168
func (s *Server) apiCreateProject(w http.ResponseWriter, r *http.Request) {169
var body struct {170
Name string `json:"name"`171
Description string `json:"description"`172
Group string `json:"group"`173
Visibility string `json:"visibility"`174
Readme bool `json:"initialize_with_readme"`175
}176
if err := readJSON(r, &body); err != nil {177
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))178
return179
}180
repo, err := s.opCreateRepo(r.Context(), apiUser(r), body.Name, body.Description, body.Group, body.Visibility, body.Readme)181
if !s.apiOK(w, r, err) {182
return183
}184
writeJSON(w, http.StatusCreated, projectJSON(repo))185
}186
187
func (s *Server) apiRepo(w http.ResponseWriter, r *http.Request, min access.Role) (store.Repo, access.Role, bool) {188
repo, err := s.Store.RepoByPath(r.Context(), r.PathValue("owner"), r.PathValue("repo"))189
if err != nil {190
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))191
return store.Repo{}, "", false192
}193
role, err := s.Store.EffectiveRole(r.Context(), apiUser(r).ID, repo.ID)194
if err != nil {195
s.writeAPIErr(w, r, fail(500, err))196
return store.Repo{}, "", false197
}198
readable := role.CanRead() || repo.Visibility == "public"199
if !readable {200
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))201
return store.Repo{}, "", false202
}203
if min.Rank() > access.RoleReadonly.Rank() && !role.AtLeast(min) {204
s.writeAPIErr(w, r, fail(403, i18n.E("err.forbidden")))205
return store.Repo{}, "", false206
}207
return repo, role, true208
}209
210
func (s *Server) apiGetProject(w http.ResponseWriter, r *http.Request) {211
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)212
if !ok {213
return214
}215
writeJSON(w, http.StatusOK, projectJSON(repo))216
}217
218
func (s *Server) apiPutProject(w http.ResponseWriter, r *http.Request) {219
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)220
if !ok {221
return222
}223
var body struct {224
Description string `json:"description"`225
Visibility string `json:"visibility"`226
}227
if err := readJSON(r, &body); err != nil {228
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))229
return230
}231
if !s.apiOK(w, r, s.opUpdateRepo(r.Context(), apiUser(r), repo, body.Description, body.Visibility)) {232
return233
}234
repo, _ = s.Store.RepoByPath(r.Context(), repo.OwnerPath, repo.Name)235
writeJSON(w, http.StatusOK, projectJSON(repo))236
}237
238
func (s *Server) apiDeleteProject(w http.ResponseWriter, r *http.Request) {239
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)240
if !ok {241
return242
}243
var body struct {244
Confirm string `json:"confirm"`245
}246
if err := readJSON(r, &body); err != nil {247
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))248
return249
}250
if !s.apiOK(w, r, s.opDeleteRepo(r.Context(), apiUser(r), repo, body.Confirm)) {251
return252
}253
writeJSON(w, http.StatusNoContent, nil)254
}255
256
func (s *Server) apiStar(w http.ResponseWriter, r *http.Request) {257
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)258
if !ok {259
return260
}261
on, err := s.opToggleStar(r.Context(), apiUser(r), repo)262
if !s.apiOK(w, r, err) {263
return264
}265
writeJSON(w, http.StatusOK, map[string]any{"starred": on})266
}267
268
func (s *Server) apiMembers(w http.ResponseWriter, r *http.Request, kind string, id int64) {269
if r.Method == http.MethodGet {270
list, err := s.Store.ListMembers(r.Context(), kind, id)271
if !s.apiOK(w, r, err) {272
return273
}274
page, per := pageQuery(r)275
rows := make([]map[string]any, 0, len(list))276
for _, m := range list {277
rows = append(rows, memberJSON(m))278
}279
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)280
return281
}282
var body struct {283
Username string `json:"username"`284
Role string `json:"role"`285
}286
if err := readJSON(r, &body); err != nil {287
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))288
return289
}290
if !s.apiOK(w, r, s.opSetMember(r.Context(), apiUser(r), kind, id, body.Username, body.Role)) {291
return292
}293
writeJSON(w, http.StatusOK, map[string]any{"username": body.Username, "role": body.Role})294
}295
296
func (s *Server) apiGroupMembers(w http.ResponseWriter, r *http.Request) {297
min := access.RoleReadonly298
if r.Method != http.MethodGet {299
min = access.RoleMaintainer300
}301
g, ok := s.apiGroup(w, r, min)302
if !ok {303
return304
}305
s.apiMembers(w, r, "group", g.ID)306
}307
308
func (s *Server) apiProjectMembers(w http.ResponseWriter, r *http.Request) {309
min := access.RoleReadonly310
if r.Method != http.MethodGet {311
min = access.RoleMaintainer312
}313
repo, _, ok := s.apiRepo(w, r, min)314
if !ok {315
return316
}317
s.apiMembers(w, r, "repo", repo.ID)318
}319
320
func (s *Server) apiDeleteMember(w http.ResponseWriter, r *http.Request, kind string, id int64) {321
if !s.apiOK(w, r, s.opRemoveMember(r.Context(), apiUser(r), kind, id, r.PathValue("username"))) {322
return323
}324
writeJSON(w, http.StatusNoContent, nil)325
}326
327
func (s *Server) apiDeleteGroupMember(w http.ResponseWriter, r *http.Request) {328
g, ok := s.apiGroup(w, r, access.RoleMaintainer)329
if !ok {330
return331
}332
s.apiDeleteMember(w, r, "group", g.ID)333
}334
335
func (s *Server) apiDeleteProjectMember(w http.ResponseWriter, r *http.Request) {336
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)337
if !ok {338
return339
}340
s.apiDeleteMember(w, r, "repo", repo.ID)341
}342
343
func secretJSON(m store.SecretMeta) map[string]any {344
return map[string]any{"name": m.Name, "protected": m.Protected, "created_at": rfcTime(m.CreatedAt)}345
}346
347
func (s *Server) apiSecrets(w http.ResponseWriter, r *http.Request, kind string, id int64) {348
if r.Method == http.MethodGet {349
list, err := s.Store.ListSecrets(r.Context(), kind, id)350
if !s.apiOK(w, r, err) {351
return352
}353
rows := make([]map[string]any, 0, len(list))354
for _, m := range list {355
rows = append(rows, secretJSON(m))356
}357
page, per := pageQuery(r)358
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)359
return360
}361
var body struct {362
Name string `json:"name"`363
Value string `json:"value"`364
Protected bool `json:"protected"`365
}366
if err := readJSON(r, &body); err != nil {367
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))368
return369
}370
if !s.apiOK(w, r, s.opPutSecret(r.Context(), apiUser(r), kind, id, body.Name, body.Value, body.Protected)) {371
return372
}373
writeJSON(w, http.StatusOK, map[string]any{"name": body.Name})374
}375
376
func (s *Server) apiGroupSecrets(w http.ResponseWriter, r *http.Request) {377
min := access.RoleReadonly378
if r.Method != http.MethodGet {379
min = access.RoleMaintainer380
}381
g, ok := s.apiGroup(w, r, min)382
if !ok {383
return384
}385
if r.Method == http.MethodGet {386
if err := s.manageScope(r.Context(), apiUser(r), "group", g.ID); err != nil {387
s.writeAPIErr(w, r, err)388
return389
}390
}391
s.apiSecrets(w, r, "group", g.ID)392
}393
394
func (s *Server) apiProjectSecrets(w http.ResponseWriter, r *http.Request) {395
min := access.RoleReadonly396
if r.Method != http.MethodGet {397
min = access.RoleMaintainer398
}399
repo, _, ok := s.apiRepo(w, r, min)400
if !ok {401
return402
}403
if r.Method == http.MethodGet {404
if err := s.manageScope(r.Context(), apiUser(r), "repo", repo.ID); err != nil {405
s.writeAPIErr(w, r, err)406
return407
}408
}409
s.apiSecrets(w, r, "repo", repo.ID)410
}411
412
func (s *Server) apiDeleteSecret(w http.ResponseWriter, r *http.Request, kind string, id int64) {413
if !s.apiOK(w, r, s.opDeleteSecret(r.Context(), apiUser(r), kind, id, r.PathValue("name"))) {414
return415
}416
writeJSON(w, http.StatusNoContent, nil)417
}418
419
func (s *Server) apiDeleteGroupSecret(w http.ResponseWriter, r *http.Request) {420
g, ok := s.apiGroup(w, r, access.RoleMaintainer)421
if !ok {422
return423
}424
s.apiDeleteSecret(w, r, "group", g.ID)425
}426
427
func (s *Server) apiDeleteProjectSecret(w http.ResponseWriter, r *http.Request) {428
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)429
if !ok {430
return431
}432
s.apiDeleteSecret(w, r, "repo", repo.ID)433
}434
435
func hookJSON(h store.Webhook) map[string]any {436
return map[string]any{437
"id": h.ID, "name": h.Name, "preset": h.Preset, "url": h.URLTemplate,438
"method": h.Method, "events": h.Events, "branch_filter": h.BranchFilter, "active": h.Active,439
}440
}441
442
func (s *Server) apiHooks(w http.ResponseWriter, r *http.Request, kind string, id int64) {443
if r.Method == http.MethodGet {444
list, err := s.Store.ListWebhooks(r.Context(), kind, id)445
if !s.apiOK(w, r, err) {446
return447
}448
rows := make([]map[string]any, 0, len(list))449
for _, h := range list {450
rows = append(rows, hookJSON(h))451
}452
page, per := pageQuery(r)453
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)454
return455
}456
var body struct {457
Name string `json:"name"`458
Preset string `json:"preset"`459
BranchFilter string `json:"branch_filter"`460
Events []string `json:"events"`461
URL string `json:"url"`462
Username string `json:"username"`463
Avatar string `json:"avatar"`464
Icon string `json:"icon"`465
Alias string `json:"alias"`466
Token string `json:"token"`467
Chat string `json:"chat"`468
Server string `json:"server"`469
Topic string `json:"topic"`470
Homeserver string `json:"homeserver"`471
Room string `json:"room"`472
Method string `json:"method"`473
ContentType string `json:"content_type"`474
Headers string `json:"headers"`475
Body string `json:"body"`476
}477
if err := readJSON(r, &body); err != nil {478
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))479
return480
}481
wid, err := s.opCreateWebhook(r.Context(), apiUser(r), kind, id, hookIn{482
Name: body.Name, Preset: body.Preset, Filter: body.BranchFilter, Events: body.Events,483
Fields: webhook.Input{484
URL: body.URL, Username: body.Username, Avatar: body.Avatar, Icon: body.Icon, Alias: body.Alias,485
Token: body.Token, Chat: body.Chat, Server: body.Server, Topic: body.Topic,486
Homeserver: body.Homeserver, Room: body.Room, Method: body.Method, ContentType: body.ContentType,487
Headers: body.Headers, Body: body.Body,488
},489
})490
if !s.apiOK(w, r, err) {491
return492
}493
writeJSON(w, http.StatusCreated, map[string]any{"id": wid})494
}495
496
func (s *Server) apiGroupHooks(w http.ResponseWriter, r *http.Request) {497
g, ok := s.apiGroup(w, r, access.RoleMaintainer)498
if !ok {499
return500
}501
s.apiHooks(w, r, "group", g.ID)502
}503
504
func (s *Server) apiProjectHooks(w http.ResponseWriter, r *http.Request) {505
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)506
if !ok {507
return508
}509
s.apiHooks(w, r, "repo", repo.ID)510
}511
512
func (s *Server) apiDeleteHook(w http.ResponseWriter, r *http.Request, kind string, id int64) {513
hid, err := strconv.ParseInt(r.PathValue("id"), 10, 64)514
if err != nil {515
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))516
return517
}518
if !s.apiOK(w, r, s.opDeleteWebhook(r.Context(), apiUser(r), kind, id, hid)) {519
return520
}521
writeJSON(w, http.StatusNoContent, nil)522
}523
524
func (s *Server) apiDeleteGroupHook(w http.ResponseWriter, r *http.Request) {525
g, ok := s.apiGroup(w, r, access.RoleMaintainer)526
if !ok {527
return528
}529
s.apiDeleteHook(w, r, "group", g.ID)530
}531
532
func (s *Server) apiDeleteProjectHook(w http.ResponseWriter, r *http.Request) {533
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)534
if !ok {535
return536
}537
s.apiDeleteHook(w, r, "repo", repo.ID)538
}539
540
func approvalJSON(p store.ApprovalPolicy, locked string) map[string]any {541
return map[string]any{542
"configured": p.Configured, "maintainer_required": p.MaintainerRequired,543
"required_count": p.RequiredCount, "developers_approve": p.DevelopersApprove,544
"locked_by": locked,545
}546
}547
548
func approvalBody(r *http.Request) (store.ApprovalPolicy, error) {549
var body struct {550
MaintainerRequired bool `json:"maintainer_required"`551
RequiredCount int `json:"required_count"`552
DevelopersApprove bool `json:"developers_approve"`553
}554
if err := readJSON(r, &body); err != nil {555
return store.ApprovalPolicy{}, fail(400, i18n.E("err.json"))556
}557
return store.ApprovalPolicy{558
MaintainerRequired: body.MaintainerRequired,559
RequiredCount: body.RequiredCount,560
DevelopersApprove: body.DevelopersApprove,561
}, nil562
}563
564
func (s *Server) apiGroupApproval(w http.ResponseWriter, r *http.Request) {565
min := access.RoleReadonly566
if r.Method != http.MethodGet {567
min = access.RoleMaintainer568
}569
g, ok := s.apiGroup(w, r, min)570
if !ok {571
return572
}573
if r.Method == http.MethodGet {574
p, err := s.Store.GetApproval(r.Context(), "group", g.ID)575
if !s.apiOK(w, r, err) {576
return577
}578
writeJSON(w, http.StatusOK, approvalJSON(p, ""))579
return580
}581
pol, err := approvalBody(r)582
if !s.apiOK(w, r, err) {583
return584
}585
if !s.apiOK(w, r, s.opSaveGroupApproval(r.Context(), apiUser(r), g, pol)) {586
return587
}588
writeJSON(w, http.StatusOK, approvalJSON(pol, ""))589
}590
591
func (s *Server) apiProjectApproval(w http.ResponseWriter, r *http.Request) {592
min := access.RoleReadonly593
if r.Method != http.MethodGet {594
min = access.RoleMaintainer595
}596
repo, _, ok := s.apiRepo(w, r, min)597
if !ok {598
return599
}600
pol, locked, err := s.Store.EffectiveApproval(r.Context(), repo)601
if !s.apiOK(w, r, err) {602
return603
}604
if r.Method == http.MethodGet {605
writeJSON(w, http.StatusOK, approvalJSON(pol, locked))606
return607
}608
next, err := approvalBody(r)609
if !s.apiOK(w, r, err) {610
return611
}612
if !s.apiOK(w, r, s.opSaveRepoApproval(r.Context(), apiUser(r), repo, next)) {613
return614
}615
writeJSON(w, http.StatusOK, approvalJSON(next, ""))616
}617
618
func (s *Server) apiLogo(w http.ResponseWriter, r *http.Request, kind string, id int64, mime string) {619
if r.Method == http.MethodGet {620
s.serveLogo(w, r, kind, id, mime)621
return622
}623
if err := r.ParseMultipartForm(2 << 20); err != nil {624
s.writeAPIErr(w, r, fail(400, i18n.E("err.badForm")))625
return626
}627
if err := s.storeLogo(r, kind, id); err != nil {628
s.writeAPIErr(w, r, fail(400, err))629
return630
}631
writeJSON(w, http.StatusOK, map[string]any{"logo": true})632
}633
634
func (s *Server) apiGroupLogo(w http.ResponseWriter, r *http.Request) {635
min := access.RoleReadonly636
if r.Method != http.MethodGet {637
min = access.RoleMaintainer638
}639
g, ok := s.apiGroup(w, r, min)640
if !ok {641
return642
}643
s.apiLogo(w, r, "group", g.ID, g.LogoMIME)644
}645
646
func (s *Server) apiProjectLogo(w http.ResponseWriter, r *http.Request) {647
min := access.RoleReadonly648
if r.Method != http.MethodGet {649
min = access.RoleMaintainer650
}651
repo, _, ok := s.apiRepo(w, r, min)652
if !ok {653
return654
}655
s.apiLogo(w, r, "repo", repo.ID, repo.LogoMIME)656
}657
658
func (s *Server) apiPatterns(w http.ResponseWriter, r *http.Request, tag bool) {659
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)660
if !ok {661
return662
}663
if r.Method == http.MethodGet {664
var list []string665
var err error666
if tag {667
list, err = s.Store.ProtectedTagPatterns(r.Context(), repo.ID)668
} else {669
list, err = s.Store.ProtectedPatterns(r.Context(), repo.ID)670
}671
if !s.apiOK(w, r, err) {672
return673
}674
if list == nil {675
list = []string{}676
}677
writeJSON(w, http.StatusOK, list)678
return679
}680
if _, _, ok := s.apiRepo(w, r, access.RoleMaintainer); !ok {681
return682
}683
var body struct {684
Pattern string `json:"pattern"`685
}686
if err := readJSON(r, &body); err != nil {687
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))688
return689
}690
if !s.apiOK(w, r, s.opProtect(r.Context(), apiUser(r), repo, body.Pattern, tag)) {691
return692
}693
writeJSON(w, http.StatusCreated, map[string]any{"pattern": body.Pattern})694
}695
696
func (s *Server) apiProtectBranches(w http.ResponseWriter, r *http.Request) {697
s.apiPatterns(w, r, false)698
}699
700
func (s *Server) apiProtectTags(w http.ResponseWriter, r *http.Request) {701
s.apiPatterns(w, r, true)702
}703
704
func (s *Server) apiUnprotect(w http.ResponseWriter, r *http.Request, tag bool) {705
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)706
if !ok {707
return708
}709
name := "pattern"710
if tag {711
name = "pattern"712
}713
pattern := r.PathValue(name)714
if !s.apiOK(w, r, s.opUnprotect(r.Context(), apiUser(r), repo, pattern, tag)) {715
return716
}717
writeJSON(w, http.StatusNoContent, nil)718
}719
720
func (s *Server) apiUnprotectBranch(w http.ResponseWriter, r *http.Request) {721
s.apiUnprotect(w, r, false)722
}723
724
func (s *Server) apiUnprotectTag(w http.ResponseWriter, r *http.Request) {725
s.apiUnprotect(w, r, true)726
}@@ -0,0 +1,586 @@
1
package server
2
3
import (
4
"net/http"
5
"strconv"
6
"strings"
7
8
"gitlab.com/Timfa/bluegit/internal/access"
9
"gitlab.com/Timfa/bluegit/internal/i18n"
10
"gitlab.com/Timfa/bluegit/internal/images"
11
"gitlab.com/Timfa/bluegit/internal/store"
12
)
13
14
func mrJSON(mr store.MergeRequest) map[string]any {
15
return map[string]any{
16
"id": mr.ID, "iid": mr.Number, "title": mr.Title, "description": mr.Description,
17
"source_branch": mr.SourceBranch, "target_branch": mr.TargetBranch,
18
"author": mr.Author, "state": mr.Status, "draft": mr.Draft, "labels": mr.Labels,
19
"created_at": rfcTime(mr.CreatedAt), "updated_at": rfcTime(mr.UpdatedAt),
20
}
21
}
22
23
func (s *Server) apiMRs(w http.ResponseWriter, r *http.Request) {
24
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
25
if !ok {
26
return
27
}
28
if r.Method == http.MethodPost {
29
var body struct {
30
Title string `json:"title"`
31
Description string `json:"description"`
32
SourceBranch string `json:"source_branch"`
33
TargetBranch string `json:"target_branch"`
34
Draft bool `json:"draft"`
35
}
36
if err := readJSON(r, &body); err != nil {
37
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
38
return
39
}
40
mr, err := s.opCreateMR(r.Context(), apiUser(r), repo, body.Title, body.Description, body.SourceBranch, body.TargetBranch, body.Draft)
41
if !s.apiOK(w, r, err) {
42
return
43
}
44
writeJSON(w, http.StatusCreated, mrJSON(mr))
45
return
46
}
47
list, err := s.Store.ListMergeRequests(r.Context(), repo.ID)
48
if !s.apiOK(w, r, err) {
49
return
50
}
51
page, per := pageQuery(r)
52
rows := make([]map[string]any, 0, len(list))
53
for _, mr := range list {
54
rows = append(rows, mrJSON(mr))
55
}
56
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
57
}
58
59
func (s *Server) apiMR(w http.ResponseWriter, r *http.Request) {
60
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
61
if !ok {
62
return
63
}
64
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
65
if err != nil {
66
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
67
return
68
}
69
if r.Method == http.MethodPut {
70
var body struct {
71
Title string `json:"title"`
72
Description string `json:"description"`
73
Labels string `json:"labels"`
74
}
75
if err := readJSON(r, &body); err != nil {
76
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
77
return
78
}
79
mr, err := s.opUpdateMR(r.Context(), apiUser(r), repo, n, body.Title, body.Description, body.Labels)
80
if !s.apiOK(w, r, err) {
81
return
82
}
83
writeJSON(w, http.StatusOK, mrJSON(mr))
84
return
85
}
86
mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
87
if err != nil {
88
s.writeAPIErr(w, r, notFound(err))
89
return
90
}
91
writeJSON(w, http.StatusOK, mrJSON(mr))
92
}
93
94
func (s *Server) apiMRNotes(w http.ResponseWriter, r *http.Request) {
95
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
96
if !ok {
97
return
98
}
99
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
100
if err != nil {
101
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
102
return
103
}
104
if r.Method == http.MethodGet {
105
mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
106
if err != nil {
107
s.writeAPIErr(w, r, notFound(err))
108
return
109
}
110
notes, err := s.Store.ListNotes(r.Context(), mr.ID)
111
if !s.apiOK(w, r, err) {
112
return
113
}
114
rows := make([]map[string]any, 0, len(notes))
115
for _, note := range notes {
116
rows = append(rows, map[string]any{
117
"id": note.ID, "body": note.Body, "author": note.Author,
118
"file_path": note.FilePath, "line_start": note.LineStart, "line_end": note.LineEnd,
119
"suggestion": note.Suggestion, "parent_id": note.ParentID, "created_at": rfcTime(note.CreatedAt),
120
})
121
}
122
page, per := pageQuery(r)
123
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
124
return
125
}
126
var body struct {
127
Body string `json:"body"`
128
Path string `json:"path"`
129
LineStart int `json:"line_start"`
130
LineEnd int `json:"line_end"`
131
ParentID int64 `json:"parent_id"`
132
}
133
if err := readJSON(r, &body); err != nil {
134
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
135
return
136
}
137
note, err := s.opAddNote(r, apiUser(r), repo, n, body.Body, body.Path, body.LineStart, body.LineEnd, body.ParentID)
138
if !s.apiOK(w, r, err) {
139
return
140
}
141
writeJSON(w, http.StatusCreated, map[string]any{"id": note.ID})
142
}
143
144
func (s *Server) apiReview(w http.ResponseWriter, r *http.Request) {
145
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
146
if !ok {
147
return
148
}
149
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
150
if err != nil {
151
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
152
return
153
}
154
var body struct {
155
Status string `json:"status"`
156
}
157
if err := readJSON(r, &body); err != nil {
158
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
159
return
160
}
161
if !s.apiOK(w, r, s.opReview(r.Context(), apiUser(r), repo, n, body.Status)) {
162
return
163
}
164
writeJSON(w, http.StatusOK, map[string]any{"status": body.Status})
165
}
166
167
func (s *Server) apiDismissReview(w http.ResponseWriter, r *http.Request) {
168
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)
169
if !ok {
170
return
171
}
172
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
173
if err != nil {
174
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
175
return
176
}
177
var body struct {
178
UserID int64 `json:"user_id"`
179
}
180
if err := readJSON(r, &body); err != nil {
181
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
182
return
183
}
184
if !s.apiOK(w, r, s.opDismissReview(r.Context(), apiUser(r), repo, n, body.UserID)) {
185
return
186
}
187
writeJSON(w, http.StatusOK, map[string]any{"status": "dismissed"})
188
}
189
190
func (s *Server) apiSuggestions(w http.ResponseWriter, r *http.Request) {
191
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
192
if !ok {
193
return
194
}
195
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
196
if err != nil {
197
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
198
return
199
}
200
var body struct {
201
Title string `json:"title"`
202
Description string `json:"description"`
203
IDs []int64 `json:"ids"`
204
}
205
if err := readJSON(r, &body); err != nil {
206
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
207
return
208
}
209
if !s.apiOK(w, r, s.opApplySuggestions(r.Context(), apiUser(r), repo, n, body.Title, body.Description, body.IDs)) {
210
return
211
}
212
writeJSON(w, http.StatusOK, map[string]any{"applied": len(body.IDs)})
213
}
214
215
func (s *Server) apiMerge(w http.ResponseWriter, r *http.Request) {
216
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
217
if !ok {
218
return
219
}
220
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
221
if err != nil {
222
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
223
return
224
}
225
if !s.apiOK(w, r, s.opMergeMR(r, apiUser(r), repo, n)) {
226
return
227
}
228
writeJSON(w, http.StatusOK, map[string]any{"state": "merged"})
229
}
230
231
func (s *Server) apiCloseMR(w http.ResponseWriter, r *http.Request) {
232
s.apiSetMR(w, r, false)
233
}
234
235
func (s *Server) apiReopenMR(w http.ResponseWriter, r *http.Request) {
236
s.apiSetMR(w, r, true)
237
}
238
239
func (s *Server) apiSetMR(w http.ResponseWriter, r *http.Request, reopen bool) {
240
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
241
if !ok {
242
return
243
}
244
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
245
if err != nil {
246
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
247
return
248
}
249
if !s.apiOK(w, r, s.opCloseMR(r.Context(), apiUser(r), repo, n, reopen)) {
250
return
251
}
252
state := "closed"
253
if reopen {
254
state = "open"
255
}
256
writeJSON(w, http.StatusOK, map[string]any{"state": state})
257
}
258
259
func pipeJSON(p store.Pipeline) map[string]any {
260
return map[string]any{
261
"id": p.ID, "sha": p.CommitSHA, "ref": p.Ref, "status": p.Status, "source": p.Source,
262
"actor": p.Actor, "created_at": rfcTime(p.CreatedAt), "started_at": rfcTime(p.StartedAt), "finished_at": rfcTime(p.FinishedAt),
263
}
264
}
265
266
func jobJSON(j store.Job) map[string]any {
267
return map[string]any{
268
"id": j.ID, "name": j.Name, "stage": j.Stage, "status": j.Status, "when": j.When,
269
"allow_failure": j.AllowFailure, "started_at": rfcTime(j.StartedAt), "finished_at": rfcTime(j.FinishedAt),
270
}
271
}
272
273
func (s *Server) apiPipelines(w http.ResponseWriter, r *http.Request) {
274
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
275
if !ok {
276
return
277
}
278
if r.Method == http.MethodPost {
279
var body struct {
280
Ref string `json:"ref"`
281
}
282
if err := readJSON(r, &body); err != nil {
283
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
284
return
285
}
286
id, err := s.opRunPipeline(r.Context(), apiUser(r), repo, body.Ref, "api")
287
if !s.apiOK(w, r, err) {
288
return
289
}
290
writeJSON(w, http.StatusCreated, map[string]any{"id": id})
291
return
292
}
293
list, err := s.Store.ListPipelines(r.Context(), repo.ID)
294
if !s.apiOK(w, r, err) {
295
return
296
}
297
page, per := pageQuery(r)
298
rows := make([]map[string]any, 0, len(list))
299
for _, p := range list {
300
rows = append(rows, pipeJSON(p))
301
}
302
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
303
}
304
305
func (s *Server) apiPipeline(w http.ResponseWriter, r *http.Request) {
306
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
307
if !ok {
308
return
309
}
310
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
311
if err != nil {
312
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
313
return
314
}
315
p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
316
if err != nil {
317
s.writeAPIErr(w, r, notFound(err))
318
return
319
}
320
writeJSON(w, http.StatusOK, pipeJSON(p))
321
}
322
323
func (s *Server) apiCancelPipeline(w http.ResponseWriter, r *http.Request) {
324
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
325
if !ok {
326
return
327
}
328
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
329
if err != nil {
330
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
331
return
332
}
333
if !s.apiOK(w, r, s.opCancelPipeline(r.Context(), apiUser(r), repo, id)) {
334
return
335
}
336
writeJSON(w, http.StatusOK, map[string]any{"id": id, "status": "canceled"})
337
}
338
339
func (s *Server) apiJobs(w http.ResponseWriter, r *http.Request) {
340
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
341
if !ok {
342
return
343
}
344
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
345
if err != nil {
346
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
347
return
348
}
349
p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)
350
if err != nil {
351
s.writeAPIErr(w, r, notFound(err))
352
return
353
}
354
jobs, err := s.Store.JobsByPipeline(r.Context(), p.ID)
355
if !s.apiOK(w, r, err) {
356
return
357
}
358
rows := make([]map[string]any, 0, len(jobs))
359
for _, j := range jobs {
360
rows = append(rows, jobJSON(j))
361
}
362
writeJSON(w, http.StatusOK, rows)
363
}
364
365
func (s *Server) apiJob(w http.ResponseWriter, r *http.Request) {
366
_, job, ok := s.apiFindJob(w, r)
367
if !ok {
368
return
369
}
370
writeJSON(w, http.StatusOK, jobJSON(job))
371
}
372
373
func (s *Server) apiJobLog(w http.ResponseWriter, r *http.Request) {
374
_, job, ok := s.apiFindJob(w, r)
375
if !ok {
376
return
377
}
378
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
379
w.WriteHeader(http.StatusOK)
380
_, _ = w.Write([]byte(job.Log))
381
}
382
383
func (s *Server) apiJobAction(w http.ResponseWriter, r *http.Request, action string) {
384
repo, p, job, ok := s.apiFindJobFull(w, r, access.RoleDeveloper)
385
if !ok {
386
return
387
}
388
updated, err := s.opJobAction(r.Context(), apiUser(r), repo, p.ID, job.ID, action)
389
if !s.apiOK(w, r, err) {
390
return
391
}
392
writeJSON(w, http.StatusOK, jobJSON(updated))
393
}
394
395
func (s *Server) apiPlayJob(w http.ResponseWriter, r *http.Request) { s.apiJobAction(w, r, "play") }
396
func (s *Server) apiRetryJob(w http.ResponseWriter, r *http.Request) {
397
s.apiJobAction(w, r, "retry")
398
}
399
func (s *Server) apiCancelJob(w http.ResponseWriter, r *http.Request) {
400
s.apiJobAction(w, r, "cancel")
401
}
402
403
func (s *Server) apiFindJob(w http.ResponseWriter, r *http.Request) (store.Pipeline, store.Job, bool) {
404
_, p, job, ok := s.apiFindJobFull(w, r, access.RoleReadonly)
405
return p, job, ok
406
}
407
408
func (s *Server) apiFindJobFull(w http.ResponseWriter, r *http.Request, min access.Role) (store.Repo, store.Pipeline, store.Job, bool) {
409
repo, _, ok := s.apiRepo(w, r, min)
410
if !ok {
411
return store.Repo{}, store.Pipeline{}, store.Job{}, false
412
}
413
pid, err := strconv.ParseInt(r.PathValue("id"), 10, 64)
414
if err != nil {
415
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
416
return store.Repo{}, store.Pipeline{}, store.Job{}, false
417
}
418
jid, err := strconv.ParseInt(r.PathValue("job"), 10, 64)
419
if err != nil {
420
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
421
return store.Repo{}, store.Pipeline{}, store.Job{}, false
422
}
423
p, err := s.Store.PipelineByID(r.Context(), repo.ID, pid)
424
if err != nil {
425
s.writeAPIErr(w, r, notFound(err))
426
return store.Repo{}, store.Pipeline{}, store.Job{}, false
427
}
428
jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)
429
for _, j := range jobs {
430
if j.ID == jid {
431
return repo, p, j, true
432
}
433
}
434
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
435
return store.Repo{}, store.Pipeline{}, store.Job{}, false
436
}
437
438
func (s *Server) apiArtifacts(w http.ResponseWriter, r *http.Request) {
439
_, job, ok := s.apiFindJob(w, r)
440
if !ok {
441
return
442
}
443
list, err := s.Store.ListArtifacts(r.Context(), job.ID)
444
if !s.apiOK(w, r, err) {
445
return
446
}
447
rows := make([]map[string]any, 0, len(list))
448
for _, a := range list {
449
rows = append(rows, map[string]any{"path": a.Path, "size": a.Size})
450
}
451
writeJSON(w, http.StatusOK, rows)
452
}
453
454
func (s *Server) apiArtifact(w http.ResponseWriter, r *http.Request) {
455
_, job, ok := s.apiFindJob(w, r)
456
if !ok {
457
return
458
}
459
want := r.PathValue("path")
460
if strings.Contains(want, "..") {
461
s.writeAPIErr(w, r, fail(400, i18n.E("err.sugFile")))
462
return
463
}
464
list, err := s.Store.ListArtifacts(r.Context(), job.ID)
465
if !s.apiOK(w, r, err) {
466
return
467
}
468
for _, a := range list {
469
if a.Path == want {
470
http.ServeFile(w, r, a.StoragePath)
471
return
472
}
473
}
474
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
475
}
476
477
func (s *Server) apiCIFile(w http.ResponseWriter, r *http.Request) {
478
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
479
if !ok {
480
return
481
}
482
if r.Method == http.MethodPut {
483
var body struct {
484
Branch string `json:"branch"`
485
Base string `json:"base"`
486
Message string `json:"message"`
487
Content string `json:"content"`
488
OpenMR bool `json:"open_mr"`
489
}
490
if err := readJSON(r, &body); err != nil {
491
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
492
return
493
}
494
sha, number, err := s.opSaveCI(r.Context(), apiUser(r), repo, body.Base, body.Branch, body.Message, body.Content, body.OpenMR)
495
if !s.apiOK(w, r, err) {
496
return
497
}
498
writeJSON(w, http.StatusOK, map[string]any{"id": sha, "merge_request": number})
499
return
500
}
501
body, err := s.opCIFile(r.Context(), repo, r.URL.Query().Get("ref"))
502
if !s.apiOK(w, r, err) {
503
return
504
}
505
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
506
w.WriteHeader(http.StatusOK)
507
_, _ = w.Write([]byte(body))
508
}
509
510
func (s *Server) apiLintCI(w http.ResponseWriter, r *http.Request) {
511
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
512
if !ok {
513
return
514
}
515
var body struct {
516
Body string `json:"body"`
517
Ref string `json:"ref"`
518
}
519
if err := readJSON(r, &body); err != nil {
520
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
521
return
522
}
523
out, err := s.opLintCI(r, repo, body.Body, body.Ref)
524
if !s.apiOK(w, r, err) {
525
return
526
}
527
writeJSON(w, http.StatusOK, out)
528
}
529
530
func (s *Server) apiPresets(w http.ResponseWriter, r *http.Request) {
531
set, err := images.Effective(s.Cfg.CI.ImageOverrides())
532
if err != nil {
533
s.writeAPIErr(w, r, fail(500, err))
534
return
535
}
536
rows := make([]map[string]any, 0, len(set))
537
for _, p := range set {
538
rows = append(rows, map[string]any{"name": "bluegit/" + p.Name, "from": p.From, "runtime": p.Runtime, "tools": p.Tools, "direct": p.Direct})
539
}
540
writeJSON(w, http.StatusOK, rows)
541
}
542
543
func (s *Server) apiReleases(w http.ResponseWriter, r *http.Request) {
544
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
545
if !ok {
546
return
547
}
548
list, err := s.Store.ListReleases(r.Context(), repo.ID)
549
if !s.apiOK(w, r, err) {
550
return
551
}
552
page, per := pageQuery(r)
553
rows := make([]map[string]any, 0, len(list))
554
for _, rel := range list {
555
assets := make([]map[string]any, 0, len(rel.Assets))
556
for _, a := range rel.Assets {
557
assets = append(assets, map[string]any{"name": a.Name, "size": a.Size})
558
}
559
rows = append(rows, map[string]any{
560
"id": rel.ID, "tag": rel.Tag, "commit": rel.CommitSHA, "name": rel.Name, "body": rel.Body,
561
"created_at": rfcTime(rel.CreatedAt), "assets": assets,
562
})
563
}
564
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
565
}
566
567
func (s *Server) apiReleaseAsset(w http.ResponseWriter, r *http.Request) {
568
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
569
if !ok {
570
return
571
}
572
rel, err := s.Store.ReleaseByTag(r.Context(), repo.ID, r.PathValue("tag"))
573
if err != nil {
574
s.writeAPIErr(w, r, notFound(err))
575
return
576
}
577
name := r.PathValue("name")
578
for _, a := range rel.Assets {
579
if a.Name == name {
580
w.Header().Set("Content-Disposition", "attachment; filename=\""+strings.ReplaceAll(name, "\"", "")+"\"")
581
http.ServeFile(w, r, a.StoragePath)
582
return
583
}
584
}
585
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
586
}
@@ -0,0 +1,586 @@1
package server2
3
import (4
"net/http"5
"strconv"6
"strings"7
8
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/i18n"10
"gitlab.com/Timfa/bluegit/internal/images"11
"gitlab.com/Timfa/bluegit/internal/store"12
)13
14
func mrJSON(mr store.MergeRequest) map[string]any {15
return map[string]any{16
"id": mr.ID, "iid": mr.Number, "title": mr.Title, "description": mr.Description,17
"source_branch": mr.SourceBranch, "target_branch": mr.TargetBranch,18
"author": mr.Author, "state": mr.Status, "draft": mr.Draft, "labels": mr.Labels,19
"created_at": rfcTime(mr.CreatedAt), "updated_at": rfcTime(mr.UpdatedAt),20
}21
}22
23
func (s *Server) apiMRs(w http.ResponseWriter, r *http.Request) {24
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)25
if !ok {26
return27
}28
if r.Method == http.MethodPost {29
var body struct {30
Title string `json:"title"`31
Description string `json:"description"`32
SourceBranch string `json:"source_branch"`33
TargetBranch string `json:"target_branch"`34
Draft bool `json:"draft"`35
}36
if err := readJSON(r, &body); err != nil {37
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))38
return39
}40
mr, err := s.opCreateMR(r.Context(), apiUser(r), repo, body.Title, body.Description, body.SourceBranch, body.TargetBranch, body.Draft)41
if !s.apiOK(w, r, err) {42
return43
}44
writeJSON(w, http.StatusCreated, mrJSON(mr))45
return46
}47
list, err := s.Store.ListMergeRequests(r.Context(), repo.ID)48
if !s.apiOK(w, r, err) {49
return50
}51
page, per := pageQuery(r)52
rows := make([]map[string]any, 0, len(list))53
for _, mr := range list {54
rows = append(rows, mrJSON(mr))55
}56
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)57
}58
59
func (s *Server) apiMR(w http.ResponseWriter, r *http.Request) {60
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)61
if !ok {62
return63
}64
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)65
if err != nil {66
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))67
return68
}69
if r.Method == http.MethodPut {70
var body struct {71
Title string `json:"title"`72
Description string `json:"description"`73
Labels string `json:"labels"`74
}75
if err := readJSON(r, &body); err != nil {76
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))77
return78
}79
mr, err := s.opUpdateMR(r.Context(), apiUser(r), repo, n, body.Title, body.Description, body.Labels)80
if !s.apiOK(w, r, err) {81
return82
}83
writeJSON(w, http.StatusOK, mrJSON(mr))84
return85
}86
mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)87
if err != nil {88
s.writeAPIErr(w, r, notFound(err))89
return90
}91
writeJSON(w, http.StatusOK, mrJSON(mr))92
}93
94
func (s *Server) apiMRNotes(w http.ResponseWriter, r *http.Request) {95
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)96
if !ok {97
return98
}99
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)100
if err != nil {101
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))102
return103
}104
if r.Method == http.MethodGet {105
mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)106
if err != nil {107
s.writeAPIErr(w, r, notFound(err))108
return109
}110
notes, err := s.Store.ListNotes(r.Context(), mr.ID)111
if !s.apiOK(w, r, err) {112
return113
}114
rows := make([]map[string]any, 0, len(notes))115
for _, note := range notes {116
rows = append(rows, map[string]any{117
"id": note.ID, "body": note.Body, "author": note.Author,118
"file_path": note.FilePath, "line_start": note.LineStart, "line_end": note.LineEnd,119
"suggestion": note.Suggestion, "parent_id": note.ParentID, "created_at": rfcTime(note.CreatedAt),120
})121
}122
page, per := pageQuery(r)123
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)124
return125
}126
var body struct {127
Body string `json:"body"`128
Path string `json:"path"`129
LineStart int `json:"line_start"`130
LineEnd int `json:"line_end"`131
ParentID int64 `json:"parent_id"`132
}133
if err := readJSON(r, &body); err != nil {134
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))135
return136
}137
note, err := s.opAddNote(r, apiUser(r), repo, n, body.Body, body.Path, body.LineStart, body.LineEnd, body.ParentID)138
if !s.apiOK(w, r, err) {139
return140
}141
writeJSON(w, http.StatusCreated, map[string]any{"id": note.ID})142
}143
144
func (s *Server) apiReview(w http.ResponseWriter, r *http.Request) {145
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)146
if !ok {147
return148
}149
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)150
if err != nil {151
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))152
return153
}154
var body struct {155
Status string `json:"status"`156
}157
if err := readJSON(r, &body); err != nil {158
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))159
return160
}161
if !s.apiOK(w, r, s.opReview(r.Context(), apiUser(r), repo, n, body.Status)) {162
return163
}164
writeJSON(w, http.StatusOK, map[string]any{"status": body.Status})165
}166
167
func (s *Server) apiDismissReview(w http.ResponseWriter, r *http.Request) {168
repo, _, ok := s.apiRepo(w, r, access.RoleMaintainer)169
if !ok {170
return171
}172
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)173
if err != nil {174
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))175
return176
}177
var body struct {178
UserID int64 `json:"user_id"`179
}180
if err := readJSON(r, &body); err != nil {181
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))182
return183
}184
if !s.apiOK(w, r, s.opDismissReview(r.Context(), apiUser(r), repo, n, body.UserID)) {185
return186
}187
writeJSON(w, http.StatusOK, map[string]any{"status": "dismissed"})188
}189
190
func (s *Server) apiSuggestions(w http.ResponseWriter, r *http.Request) {191
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)192
if !ok {193
return194
}195
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)196
if err != nil {197
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))198
return199
}200
var body struct {201
Title string `json:"title"`202
Description string `json:"description"`203
IDs []int64 `json:"ids"`204
}205
if err := readJSON(r, &body); err != nil {206
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))207
return208
}209
if !s.apiOK(w, r, s.opApplySuggestions(r.Context(), apiUser(r), repo, n, body.Title, body.Description, body.IDs)) {210
return211
}212
writeJSON(w, http.StatusOK, map[string]any{"applied": len(body.IDs)})213
}214
215
func (s *Server) apiMerge(w http.ResponseWriter, r *http.Request) {216
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)217
if !ok {218
return219
}220
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)221
if err != nil {222
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))223
return224
}225
if !s.apiOK(w, r, s.opMergeMR(r, apiUser(r), repo, n)) {226
return227
}228
writeJSON(w, http.StatusOK, map[string]any{"state": "merged"})229
}230
231
func (s *Server) apiCloseMR(w http.ResponseWriter, r *http.Request) {232
s.apiSetMR(w, r, false)233
}234
235
func (s *Server) apiReopenMR(w http.ResponseWriter, r *http.Request) {236
s.apiSetMR(w, r, true)237
}238
239
func (s *Server) apiSetMR(w http.ResponseWriter, r *http.Request, reopen bool) {240
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)241
if !ok {242
return243
}244
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)245
if err != nil {246
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))247
return248
}249
if !s.apiOK(w, r, s.opCloseMR(r.Context(), apiUser(r), repo, n, reopen)) {250
return251
}252
state := "closed"253
if reopen {254
state = "open"255
}256
writeJSON(w, http.StatusOK, map[string]any{"state": state})257
}258
259
func pipeJSON(p store.Pipeline) map[string]any {260
return map[string]any{261
"id": p.ID, "sha": p.CommitSHA, "ref": p.Ref, "status": p.Status, "source": p.Source,262
"actor": p.Actor, "created_at": rfcTime(p.CreatedAt), "started_at": rfcTime(p.StartedAt), "finished_at": rfcTime(p.FinishedAt),263
}264
}265
266
func jobJSON(j store.Job) map[string]any {267
return map[string]any{268
"id": j.ID, "name": j.Name, "stage": j.Stage, "status": j.Status, "when": j.When,269
"allow_failure": j.AllowFailure, "started_at": rfcTime(j.StartedAt), "finished_at": rfcTime(j.FinishedAt),270
}271
}272
273
func (s *Server) apiPipelines(w http.ResponseWriter, r *http.Request) {274
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)275
if !ok {276
return277
}278
if r.Method == http.MethodPost {279
var body struct {280
Ref string `json:"ref"`281
}282
if err := readJSON(r, &body); err != nil {283
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))284
return285
}286
id, err := s.opRunPipeline(r.Context(), apiUser(r), repo, body.Ref, "api")287
if !s.apiOK(w, r, err) {288
return289
}290
writeJSON(w, http.StatusCreated, map[string]any{"id": id})291
return292
}293
list, err := s.Store.ListPipelines(r.Context(), repo.ID)294
if !s.apiOK(w, r, err) {295
return296
}297
page, per := pageQuery(r)298
rows := make([]map[string]any, 0, len(list))299
for _, p := range list {300
rows = append(rows, pipeJSON(p))301
}302
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)303
}304
305
func (s *Server) apiPipeline(w http.ResponseWriter, r *http.Request) {306
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)307
if !ok {308
return309
}310
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)311
if err != nil {312
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))313
return314
}315
p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)316
if err != nil {317
s.writeAPIErr(w, r, notFound(err))318
return319
}320
writeJSON(w, http.StatusOK, pipeJSON(p))321
}322
323
func (s *Server) apiCancelPipeline(w http.ResponseWriter, r *http.Request) {324
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)325
if !ok {326
return327
}328
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)329
if err != nil {330
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))331
return332
}333
if !s.apiOK(w, r, s.opCancelPipeline(r.Context(), apiUser(r), repo, id)) {334
return335
}336
writeJSON(w, http.StatusOK, map[string]any{"id": id, "status": "canceled"})337
}338
339
func (s *Server) apiJobs(w http.ResponseWriter, r *http.Request) {340
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)341
if !ok {342
return343
}344
id, err := strconv.ParseInt(r.PathValue("id"), 10, 64)345
if err != nil {346
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))347
return348
}349
p, err := s.Store.PipelineByID(r.Context(), repo.ID, id)350
if err != nil {351
s.writeAPIErr(w, r, notFound(err))352
return353
}354
jobs, err := s.Store.JobsByPipeline(r.Context(), p.ID)355
if !s.apiOK(w, r, err) {356
return357
}358
rows := make([]map[string]any, 0, len(jobs))359
for _, j := range jobs {360
rows = append(rows, jobJSON(j))361
}362
writeJSON(w, http.StatusOK, rows)363
}364
365
func (s *Server) apiJob(w http.ResponseWriter, r *http.Request) {366
_, job, ok := s.apiFindJob(w, r)367
if !ok {368
return369
}370
writeJSON(w, http.StatusOK, jobJSON(job))371
}372
373
func (s *Server) apiJobLog(w http.ResponseWriter, r *http.Request) {374
_, job, ok := s.apiFindJob(w, r)375
if !ok {376
return377
}378
w.Header().Set("Content-Type", "text/plain; charset=utf-8")379
w.WriteHeader(http.StatusOK)380
_, _ = w.Write([]byte(job.Log))381
}382
383
func (s *Server) apiJobAction(w http.ResponseWriter, r *http.Request, action string) {384
repo, p, job, ok := s.apiFindJobFull(w, r, access.RoleDeveloper)385
if !ok {386
return387
}388
updated, err := s.opJobAction(r.Context(), apiUser(r), repo, p.ID, job.ID, action)389
if !s.apiOK(w, r, err) {390
return391
}392
writeJSON(w, http.StatusOK, jobJSON(updated))393
}394
395
func (s *Server) apiPlayJob(w http.ResponseWriter, r *http.Request) { s.apiJobAction(w, r, "play") }396
func (s *Server) apiRetryJob(w http.ResponseWriter, r *http.Request) {397
s.apiJobAction(w, r, "retry")398
}399
func (s *Server) apiCancelJob(w http.ResponseWriter, r *http.Request) {400
s.apiJobAction(w, r, "cancel")401
}402
403
func (s *Server) apiFindJob(w http.ResponseWriter, r *http.Request) (store.Pipeline, store.Job, bool) {404
_, p, job, ok := s.apiFindJobFull(w, r, access.RoleReadonly)405
return p, job, ok406
}407
408
func (s *Server) apiFindJobFull(w http.ResponseWriter, r *http.Request, min access.Role) (store.Repo, store.Pipeline, store.Job, bool) {409
repo, _, ok := s.apiRepo(w, r, min)410
if !ok {411
return store.Repo{}, store.Pipeline{}, store.Job{}, false412
}413
pid, err := strconv.ParseInt(r.PathValue("id"), 10, 64)414
if err != nil {415
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))416
return store.Repo{}, store.Pipeline{}, store.Job{}, false417
}418
jid, err := strconv.ParseInt(r.PathValue("job"), 10, 64)419
if err != nil {420
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))421
return store.Repo{}, store.Pipeline{}, store.Job{}, false422
}423
p, err := s.Store.PipelineByID(r.Context(), repo.ID, pid)424
if err != nil {425
s.writeAPIErr(w, r, notFound(err))426
return store.Repo{}, store.Pipeline{}, store.Job{}, false427
}428
jobs, _ := s.Store.JobsByPipeline(r.Context(), p.ID)429
for _, j := range jobs {430
if j.ID == jid {431
return repo, p, j, true432
}433
}434
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))435
return store.Repo{}, store.Pipeline{}, store.Job{}, false436
}437
438
func (s *Server) apiArtifacts(w http.ResponseWriter, r *http.Request) {439
_, job, ok := s.apiFindJob(w, r)440
if !ok {441
return442
}443
list, err := s.Store.ListArtifacts(r.Context(), job.ID)444
if !s.apiOK(w, r, err) {445
return446
}447
rows := make([]map[string]any, 0, len(list))448
for _, a := range list {449
rows = append(rows, map[string]any{"path": a.Path, "size": a.Size})450
}451
writeJSON(w, http.StatusOK, rows)452
}453
454
func (s *Server) apiArtifact(w http.ResponseWriter, r *http.Request) {455
_, job, ok := s.apiFindJob(w, r)456
if !ok {457
return458
}459
want := r.PathValue("path")460
if strings.Contains(want, "..") {461
s.writeAPIErr(w, r, fail(400, i18n.E("err.sugFile")))462
return463
}464
list, err := s.Store.ListArtifacts(r.Context(), job.ID)465
if !s.apiOK(w, r, err) {466
return467
}468
for _, a := range list {469
if a.Path == want {470
http.ServeFile(w, r, a.StoragePath)471
return472
}473
}474
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))475
}476
477
func (s *Server) apiCIFile(w http.ResponseWriter, r *http.Request) {478
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)479
if !ok {480
return481
}482
if r.Method == http.MethodPut {483
var body struct {484
Branch string `json:"branch"`485
Base string `json:"base"`486
Message string `json:"message"`487
Content string `json:"content"`488
OpenMR bool `json:"open_mr"`489
}490
if err := readJSON(r, &body); err != nil {491
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))492
return493
}494
sha, number, err := s.opSaveCI(r.Context(), apiUser(r), repo, body.Base, body.Branch, body.Message, body.Content, body.OpenMR)495
if !s.apiOK(w, r, err) {496
return497
}498
writeJSON(w, http.StatusOK, map[string]any{"id": sha, "merge_request": number})499
return500
}501
body, err := s.opCIFile(r.Context(), repo, r.URL.Query().Get("ref"))502
if !s.apiOK(w, r, err) {503
return504
}505
w.Header().Set("Content-Type", "text/plain; charset=utf-8")506
w.WriteHeader(http.StatusOK)507
_, _ = w.Write([]byte(body))508
}509
510
func (s *Server) apiLintCI(w http.ResponseWriter, r *http.Request) {511
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)512
if !ok {513
return514
}515
var body struct {516
Body string `json:"body"`517
Ref string `json:"ref"`518
}519
if err := readJSON(r, &body); err != nil {520
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))521
return522
}523
out, err := s.opLintCI(r, repo, body.Body, body.Ref)524
if !s.apiOK(w, r, err) {525
return526
}527
writeJSON(w, http.StatusOK, out)528
}529
530
func (s *Server) apiPresets(w http.ResponseWriter, r *http.Request) {531
set, err := images.Effective(s.Cfg.CI.ImageOverrides())532
if err != nil {533
s.writeAPIErr(w, r, fail(500, err))534
return535
}536
rows := make([]map[string]any, 0, len(set))537
for _, p := range set {538
rows = append(rows, map[string]any{"name": "bluegit/" + p.Name, "from": p.From, "runtime": p.Runtime, "tools": p.Tools, "direct": p.Direct})539
}540
writeJSON(w, http.StatusOK, rows)541
}542
543
func (s *Server) apiReleases(w http.ResponseWriter, r *http.Request) {544
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)545
if !ok {546
return547
}548
list, err := s.Store.ListReleases(r.Context(), repo.ID)549
if !s.apiOK(w, r, err) {550
return551
}552
page, per := pageQuery(r)553
rows := make([]map[string]any, 0, len(list))554
for _, rel := range list {555
assets := make([]map[string]any, 0, len(rel.Assets))556
for _, a := range rel.Assets {557
assets = append(assets, map[string]any{"name": a.Name, "size": a.Size})558
}559
rows = append(rows, map[string]any{560
"id": rel.ID, "tag": rel.Tag, "commit": rel.CommitSHA, "name": rel.Name, "body": rel.Body,561
"created_at": rfcTime(rel.CreatedAt), "assets": assets,562
})563
}564
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)565
}566
567
func (s *Server) apiReleaseAsset(w http.ResponseWriter, r *http.Request) {568
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)569
if !ok {570
return571
}572
rel, err := s.Store.ReleaseByTag(r.Context(), repo.ID, r.PathValue("tag"))573
if err != nil {574
s.writeAPIErr(w, r, notFound(err))575
return576
}577
name := r.PathValue("name")578
for _, a := range rel.Assets {579
if a.Name == name {580
w.Header().Set("Content-Disposition", "attachment; filename=\""+strings.ReplaceAll(name, "\"", "")+"\"")581
http.ServeFile(w, r, a.StoragePath)582
return583
}584
}585
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))586
}@@ -0,0 +1,301 @@
1
package server
2
3
import (
4
"net/http"
5
"os/exec"
6
"strings"
7
8
"gitlab.com/Timfa/bluegit/internal/access"
9
"gitlab.com/Timfa/bluegit/internal/gitrepo"
10
"gitlab.com/Timfa/bluegit/internal/i18n"
11
)
12
13
func (s *Server) apiBranches(w http.ResponseWriter, r *http.Request) {
14
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
15
if !ok {
16
return
17
}
18
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
19
if r.Method == http.MethodGet {
20
tips, err := gitrepo.BranchTips(r.Context(), s.Git, dir)
21
if err != nil {
22
tips = nil
23
}
24
page, per := pageQuery(r)
25
rows := make([]map[string]any, 0, len(tips))
26
for _, t := range tips {
27
rows = append(rows, map[string]any{
28
"name": t.Name, "commit": t.SHA, "subject": t.Subject, "date": t.Date,
29
"default": t.Name == repo.DefaultBranch,
30
})
31
}
32
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
33
return
34
}
35
var body struct {
36
Name string `json:"name"`
37
From string `json:"from"`
38
}
39
if err := readJSON(r, &body); err != nil {
40
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
41
return
42
}
43
if !s.apiOK(w, r, s.opCreateBranch(r.Context(), apiUser(r), repo, body.Name, body.From)) {
44
return
45
}
46
writeJSON(w, http.StatusCreated, map[string]any{"name": body.Name})
47
}
48
49
func (s *Server) apiBranch(w http.ResponseWriter, r *http.Request) {
50
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
51
if !ok {
52
return
53
}
54
name := r.PathValue("branch")
55
if r.Method == http.MethodDelete {
56
var body struct {
57
Confirm string `json:"confirm"`
58
}
59
if err := readJSON(r, &body); err != nil {
60
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
61
return
62
}
63
if !s.apiOK(w, r, s.opDeleteBranch(r.Context(), apiUser(r), repo, name, body.Confirm)) {
64
return
65
}
66
writeJSON(w, http.StatusNoContent, nil)
67
return
68
}
69
var body struct {
70
Name string `json:"name"`
71
Confirm string `json:"confirm"`
72
}
73
if err := readJSON(r, &body); err != nil {
74
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
75
return
76
}
77
if !s.apiOK(w, r, s.opRenameBranch(r.Context(), apiUser(r), repo, name, body.Name, body.Confirm)) {
78
return
79
}
80
writeJSON(w, http.StatusOK, map[string]any{"name": body.Name})
81
}
82
83
func (s *Server) apiTags(w http.ResponseWriter, r *http.Request) {
84
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
85
if !ok {
86
return
87
}
88
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
89
if r.Method == http.MethodGet {
90
names, err := gitrepo.Tags(r.Context(), s.Git, dir)
91
if err != nil {
92
names = nil
93
}
94
if names == nil {
95
names = []string{}
96
}
97
page, per := pageQuery(r)
98
writePage(w, r, slicePage(names, page, per), len(names), page, per)
99
return
100
}
101
var in struct {
102
Name string `json:"name"`
103
Target string `json:"target"`
104
Message string `json:"message"`
105
}
106
if err := readJSON(r, &in); err != nil {
107
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
108
return
109
}
110
if !s.apiOK(w, r, s.opCreateTag(r.Context(), apiUser(r), repo, in.Name, in.Target, in.Message)) {
111
return
112
}
113
writeJSON(w, http.StatusCreated, map[string]any{"name": in.Name})
114
}
115
116
func (s *Server) apiDeleteTag(w http.ResponseWriter, r *http.Request) {
117
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)
118
if !ok {
119
return
120
}
121
if !s.apiOK(w, r, s.opDeleteTag(r.Context(), apiUser(r), repo, r.PathValue("tag"))) {
122
return
123
}
124
writeJSON(w, http.StatusNoContent, nil)
125
}
126
127
func (s *Server) apiTagArchive(w http.ResponseWriter, r *http.Request) {
128
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
129
if !ok {
130
return
131
}
132
name := r.PathValue("tag")
133
format := r.URL.Query().Get("format")
134
if format == "" {
135
format = "tar.gz"
136
}
137
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
138
if !gitrepo.HasTag(r.Context(), s.Git, dir, name) {
139
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
140
return
141
}
142
filename := archiveFilename(repo.Name, name, format)
143
if format == "zip" {
144
w.Header().Set("Content-Type", "application/zip")
145
} else {
146
w.Header().Set("Content-Type", "application/gzip")
147
}
148
w.Header().Set("Content-Disposition", "attachment; filename=\""+filename+"\"")
149
if err := gitrepo.Archive(r.Context(), w, s.Git, dir, repo.Name+"-"+strings.ReplaceAll(name, "/", "-"), name, format); err != nil {
150
s.writeAPIErr(w, r, fail(400, err))
151
}
152
}
153
154
func (s *Server) apiTree(w http.ResponseWriter, r *http.Request) {
155
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
156
if !ok {
157
return
158
}
159
ref := safeRev(r.URL.Query().Get("ref"), repo.DefaultBranch)
160
rel := strings.Trim(r.URL.Query().Get("path"), "/")
161
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
162
entries, err := gitrepo.Tree(r.Context(), s.Git, dir, ref, rel)
163
if err != nil {
164
writeJSON(w, http.StatusOK, []any{})
165
return
166
}
167
rows := make([]map[string]any, 0, len(entries))
168
for _, e := range entries {
169
rows = append(rows, map[string]any{"name": e.Name, "type": e.Type, "mode": e.Mode, "id": e.SHA})
170
}
171
page, per := pageQuery(r)
172
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
173
}
174
175
func (s *Server) apiFile(w http.ResponseWriter, r *http.Request) {
176
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
177
if !ok {
178
return
179
}
180
path, pathOK := repoPath(r.PathValue("path"))
181
if !pathOK || path == "" {
182
s.writeAPIErr(w, r, fail(400, i18n.E("err.sugFile")))
183
return
184
}
185
ref := safeRev(r.URL.Query().Get("ref"), repo.DefaultBranch)
186
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
187
out, err := exec.CommandContext(r.Context(), s.Git, "-C", dir, "show", ref+":"+path).Output()
188
if err != nil {
189
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
190
return
191
}
192
if strings.Contains(string(out), "\x00") {
193
w.Header().Set("Content-Type", "application/octet-stream")
194
} else {
195
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
196
}
197
w.WriteHeader(http.StatusOK)
198
_, _ = w.Write(out)
199
}
200
201
func (s *Server) apiCommits(w http.ResponseWriter, r *http.Request) {
202
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
203
if !ok {
204
return
205
}
206
if r.Method == http.MethodPost {
207
var body struct {
208
Branch string `json:"branch"`
209
StartBranch string `json:"start_branch"`
210
CommitMessage string `json:"commit_message"`
211
Actions []fileAction `json:"actions"`
212
}
213
if err := readJSON(r, &body); err != nil {
214
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))
215
return
216
}
217
sha, err := s.opCommitActions(r.Context(), apiUser(r), repo, body.Branch, body.StartBranch, body.CommitMessage, "", body.Actions)
218
if !s.apiOK(w, r, err) {
219
return
220
}
221
writeJSON(w, http.StatusCreated, map[string]any{"id": sha, "branch": body.Branch})
222
return
223
}
224
ref := safeRev(r.URL.Query().Get("ref"), repo.DefaultBranch)
225
page, per := pageQuery(r)
226
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
227
limit := page * per
228
if limit > 200 {
229
limit = 200
230
}
231
list, err := gitrepo.Log(r.Context(), s.Git, dir, ref, limit)
232
if err != nil || list == nil {
233
list = nil
234
}
235
rows := make([]map[string]any, 0, len(list))
236
for _, c := range list {
237
rows = append(rows, commitJSON(c))
238
}
239
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)
240
}
241
242
func commitJSON(c gitrepo.Commit) map[string]any {
243
return map[string]any{
244
"id": c.SHA, "short_id": c.Short, "title": c.Subject, "message": c.Body,
245
"author_name": c.Author, "author_email": c.Email, "authored_date": c.Date,
246
}
247
}
248
249
func (s *Server) apiCommit(w http.ResponseWriter, r *http.Request) {
250
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
251
if !ok {
252
return
253
}
254
sha := r.PathValue("sha")
255
if !safeSHA(sha) {
256
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
257
return
258
}
259
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
260
c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)
261
if err != nil {
262
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
263
return
264
}
265
writeJSON(w, http.StatusOK, commitJSON(c))
266
}
267
268
func (s *Server) apiCommitDiff(w http.ResponseWriter, r *http.Request) {
269
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)
270
if !ok {
271
return
272
}
273
sha := r.PathValue("sha")
274
if !safeSHA(sha) {
275
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
276
return
277
}
278
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
279
parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, sha)
280
if err != nil {
281
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))
282
return
283
}
284
out := make([]map[string]any, 0, len(files))
285
for _, f := range files {
286
var b strings.Builder
287
for _, ln := range f.Lines {
288
b.WriteString(ln.Kind)
289
b.WriteString(ln.Text)
290
b.WriteByte('\n')
291
}
292
out = append(out, map[string]any{
293
"status": f.Status, "path": f.Path, "old_path": f.OldPath,
294
"added": f.Added, "deleted": f.Deleted, "binary": f.Binary, "diff": b.String(),
295
})
296
}
297
if parents == nil {
298
parents = []string{}
299
}
300
writeJSON(w, http.StatusOK, map[string]any{"id": sha, "parents": parents, "files": out})
301
}
@@ -0,0 +1,301 @@1
package server2
3
import (4
"net/http"5
"os/exec"6
"strings"7
8
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/gitrepo"10
"gitlab.com/Timfa/bluegit/internal/i18n"11
)12
13
func (s *Server) apiBranches(w http.ResponseWriter, r *http.Request) {14
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)15
if !ok {16
return17
}18
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)19
if r.Method == http.MethodGet {20
tips, err := gitrepo.BranchTips(r.Context(), s.Git, dir)21
if err != nil {22
tips = nil23
}24
page, per := pageQuery(r)25
rows := make([]map[string]any, 0, len(tips))26
for _, t := range tips {27
rows = append(rows, map[string]any{28
"name": t.Name, "commit": t.SHA, "subject": t.Subject, "date": t.Date,29
"default": t.Name == repo.DefaultBranch,30
})31
}32
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)33
return34
}35
var body struct {36
Name string `json:"name"`37
From string `json:"from"`38
}39
if err := readJSON(r, &body); err != nil {40
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))41
return42
}43
if !s.apiOK(w, r, s.opCreateBranch(r.Context(), apiUser(r), repo, body.Name, body.From)) {44
return45
}46
writeJSON(w, http.StatusCreated, map[string]any{"name": body.Name})47
}48
49
func (s *Server) apiBranch(w http.ResponseWriter, r *http.Request) {50
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)51
if !ok {52
return53
}54
name := r.PathValue("branch")55
if r.Method == http.MethodDelete {56
var body struct {57
Confirm string `json:"confirm"`58
}59
if err := readJSON(r, &body); err != nil {60
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))61
return62
}63
if !s.apiOK(w, r, s.opDeleteBranch(r.Context(), apiUser(r), repo, name, body.Confirm)) {64
return65
}66
writeJSON(w, http.StatusNoContent, nil)67
return68
}69
var body struct {70
Name string `json:"name"`71
Confirm string `json:"confirm"`72
}73
if err := readJSON(r, &body); err != nil {74
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))75
return76
}77
if !s.apiOK(w, r, s.opRenameBranch(r.Context(), apiUser(r), repo, name, body.Name, body.Confirm)) {78
return79
}80
writeJSON(w, http.StatusOK, map[string]any{"name": body.Name})81
}82
83
func (s *Server) apiTags(w http.ResponseWriter, r *http.Request) {84
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)85
if !ok {86
return87
}88
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)89
if r.Method == http.MethodGet {90
names, err := gitrepo.Tags(r.Context(), s.Git, dir)91
if err != nil {92
names = nil93
}94
if names == nil {95
names = []string{}96
}97
page, per := pageQuery(r)98
writePage(w, r, slicePage(names, page, per), len(names), page, per)99
return100
}101
var in struct {102
Name string `json:"name"`103
Target string `json:"target"`104
Message string `json:"message"`105
}106
if err := readJSON(r, &in); err != nil {107
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))108
return109
}110
if !s.apiOK(w, r, s.opCreateTag(r.Context(), apiUser(r), repo, in.Name, in.Target, in.Message)) {111
return112
}113
writeJSON(w, http.StatusCreated, map[string]any{"name": in.Name})114
}115
116
func (s *Server) apiDeleteTag(w http.ResponseWriter, r *http.Request) {117
repo, _, ok := s.apiRepo(w, r, access.RoleDeveloper)118
if !ok {119
return120
}121
if !s.apiOK(w, r, s.opDeleteTag(r.Context(), apiUser(r), repo, r.PathValue("tag"))) {122
return123
}124
writeJSON(w, http.StatusNoContent, nil)125
}126
127
func (s *Server) apiTagArchive(w http.ResponseWriter, r *http.Request) {128
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)129
if !ok {130
return131
}132
name := r.PathValue("tag")133
format := r.URL.Query().Get("format")134
if format == "" {135
format = "tar.gz"136
}137
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)138
if !gitrepo.HasTag(r.Context(), s.Git, dir, name) {139
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))140
return141
}142
filename := archiveFilename(repo.Name, name, format)143
if format == "zip" {144
w.Header().Set("Content-Type", "application/zip")145
} else {146
w.Header().Set("Content-Type", "application/gzip")147
}148
w.Header().Set("Content-Disposition", "attachment; filename=\""+filename+"\"")149
if err := gitrepo.Archive(r.Context(), w, s.Git, dir, repo.Name+"-"+strings.ReplaceAll(name, "/", "-"), name, format); err != nil {150
s.writeAPIErr(w, r, fail(400, err))151
}152
}153
154
func (s *Server) apiTree(w http.ResponseWriter, r *http.Request) {155
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)156
if !ok {157
return158
}159
ref := safeRev(r.URL.Query().Get("ref"), repo.DefaultBranch)160
rel := strings.Trim(r.URL.Query().Get("path"), "/")161
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)162
entries, err := gitrepo.Tree(r.Context(), s.Git, dir, ref, rel)163
if err != nil {164
writeJSON(w, http.StatusOK, []any{})165
return166
}167
rows := make([]map[string]any, 0, len(entries))168
for _, e := range entries {169
rows = append(rows, map[string]any{"name": e.Name, "type": e.Type, "mode": e.Mode, "id": e.SHA})170
}171
page, per := pageQuery(r)172
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)173
}174
175
func (s *Server) apiFile(w http.ResponseWriter, r *http.Request) {176
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)177
if !ok {178
return179
}180
path, pathOK := repoPath(r.PathValue("path"))181
if !pathOK || path == "" {182
s.writeAPIErr(w, r, fail(400, i18n.E("err.sugFile")))183
return184
}185
ref := safeRev(r.URL.Query().Get("ref"), repo.DefaultBranch)186
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)187
out, err := exec.CommandContext(r.Context(), s.Git, "-C", dir, "show", ref+":"+path).Output()188
if err != nil {189
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))190
return191
}192
if strings.Contains(string(out), "\x00") {193
w.Header().Set("Content-Type", "application/octet-stream")194
} else {195
w.Header().Set("Content-Type", "text/plain; charset=utf-8")196
}197
w.WriteHeader(http.StatusOK)198
_, _ = w.Write(out)199
}200
201
func (s *Server) apiCommits(w http.ResponseWriter, r *http.Request) {202
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)203
if !ok {204
return205
}206
if r.Method == http.MethodPost {207
var body struct {208
Branch string `json:"branch"`209
StartBranch string `json:"start_branch"`210
CommitMessage string `json:"commit_message"`211
Actions []fileAction `json:"actions"`212
}213
if err := readJSON(r, &body); err != nil {214
s.writeAPIErr(w, r, fail(400, i18n.E("err.json")))215
return216
}217
sha, err := s.opCommitActions(r.Context(), apiUser(r), repo, body.Branch, body.StartBranch, body.CommitMessage, "", body.Actions)218
if !s.apiOK(w, r, err) {219
return220
}221
writeJSON(w, http.StatusCreated, map[string]any{"id": sha, "branch": body.Branch})222
return223
}224
ref := safeRev(r.URL.Query().Get("ref"), repo.DefaultBranch)225
page, per := pageQuery(r)226
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)227
limit := page * per228
if limit > 200 {229
limit = 200230
}231
list, err := gitrepo.Log(r.Context(), s.Git, dir, ref, limit)232
if err != nil || list == nil {233
list = nil234
}235
rows := make([]map[string]any, 0, len(list))236
for _, c := range list {237
rows = append(rows, commitJSON(c))238
}239
writePage(w, r, slicePage(rows, page, per), len(rows), page, per)240
}241
242
func commitJSON(c gitrepo.Commit) map[string]any {243
return map[string]any{244
"id": c.SHA, "short_id": c.Short, "title": c.Subject, "message": c.Body,245
"author_name": c.Author, "author_email": c.Email, "authored_date": c.Date,246
}247
}248
249
func (s *Server) apiCommit(w http.ResponseWriter, r *http.Request) {250
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)251
if !ok {252
return253
}254
sha := r.PathValue("sha")255
if !safeSHA(sha) {256
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))257
return258
}259
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)260
c, err := gitrepo.Show(r.Context(), s.Git, dir, sha)261
if err != nil {262
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))263
return264
}265
writeJSON(w, http.StatusOK, commitJSON(c))266
}267
268
func (s *Server) apiCommitDiff(w http.ResponseWriter, r *http.Request) {269
repo, _, ok := s.apiRepo(w, r, access.RoleReadonly)270
if !ok {271
return272
}273
sha := r.PathValue("sha")274
if !safeSHA(sha) {275
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))276
return277
}278
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)279
parents, files, err := gitrepo.CommitPatch(r.Context(), s.Git, dir, sha)280
if err != nil {281
s.writeAPIErr(w, r, fail(404, i18n.E("err.notFound")))282
return283
}284
out := make([]map[string]any, 0, len(files))285
for _, f := range files {286
var b strings.Builder287
for _, ln := range f.Lines {288
b.WriteString(ln.Kind)289
b.WriteString(ln.Text)290
b.WriteByte('\n')291
}292
out = append(out, map[string]any{293
"status": f.Status, "path": f.Path, "old_path": f.OldPath,294
"added": f.Added, "deleted": f.Deleted, "binary": f.Binary, "diff": b.String(),295
})296
}297
if parents == nil {298
parents = []string{}299
}300
writeJSON(w, http.StatusOK, map[string]any{"id": sha, "parents": parents, "files": out})301
}@@ -0,0 +1,332 @@
1
package server
2
3
import (
4
"bytes"
5
"context"
6
"encoding/json"
7
"io"
8
"net/http"
9
"net/http/httptest"
10
"strconv"
11
"strings"
12
13
"gitlab.com/Timfa/bluegit/internal/access"
14
"gitlab.com/Timfa/bluegit/internal/i18n"
15
"gitlab.com/Timfa/bluegit/internal/store"
16
)
17
18
type actorKey struct{}
19
20
type apiActor struct {
21
User store.User
22
Scopes access.Scopes
23
Via string
24
}
25
26
type apiAuth int
27
28
const (
29
authUser apiAuth = iota
30
authPublic
31
authRelease
32
)
33
34
type apiHandler func(*Server, http.ResponseWriter, *http.Request)
35
36
type apiRoute struct {
37
Method string
38
Path string
39
Class access.ScopeClass
40
Auth apiAuth
41
Summary string
42
Handler apiHandler
43
}
44
45
// apiRouteTaken zegt of server.go die methode en dat pad al registreert.
46
// ServeMux weigert hetzelfde patroon twee keer. De expliciete handlers
47
// blijven, de catalogus noemt het pad nog voor OpenAPI.
48
func apiRouteTaken(method, path string) bool {
49
switch method + " " + path {
50
case "POST /api/v1/repos/{owner}/{repo}/releases",
51
"GET /api/v1/groups/{path}/secrets",
52
"POST /api/v1/groups/{path}/secrets",
53
"DELETE /api/v1/groups/{path}/secrets/{name}":
54
return true
55
default:
56
return false
57
}
58
}
59
60
func (s *Server) mountAPI(mux *http.ServeMux) {
61
mux.HandleFunc("GET /api/v1/openapi.json", func(w http.ResponseWriter, r *http.Request) {
62
s.serveAPI(w, r, apiRoute{Method: http.MethodGet, Path: "/api/v1/openapi.json", Class: access.ScopePublic, Auth: authPublic, Summary: "OpenAPI document", Handler: (*Server).openAPI})
63
})
64
for _, rt := range apiCatalog {
65
rt := rt
66
if apiRouteTaken(rt.Method, rt.Path) {
67
continue
68
}
69
mux.HandleFunc(rt.Method+" "+rt.Path, func(w http.ResponseWriter, r *http.Request) {
70
s.serveAPI(w, r, rt)
71
})
72
}
73
}
74
75
func (s *Server) serveAPI(w http.ResponseWriter, r *http.Request, rt apiRoute) {
76
w.Header().Set("Cache-Control", "no-store")
77
if rt.Auth == authPublic {
78
rt.Handler(s, w, r)
79
return
80
}
81
if rt.Auth == authRelease {
82
tok := tokenFrom(r)
83
if strings.HasPrefix(tok, "bgj_") {
84
rt.Handler(s, w, r)
85
return
86
}
87
}
88
actor, ok := r.Context().Value(actorKey{}).(apiActor)
89
if !ok {
90
tok := tokenFrom(r)
91
if tok == "" || !strings.HasPrefix(tok, "bg_") {
92
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.apiAuth")))
93
return
94
}
95
auth, err := s.Store.AuthenticateToken(r.Context(), tok)
96
if err != nil {
97
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, err))
98
return
99
}
100
actor = apiActor{User: auth.User, Scopes: access.StoredScopes(auth.Token.Scopes), Via: "token"}
101
}
102
if !actor.Scopes.Allows(rt.Class) {
103
s.writeAPIErr(w, r, fail(http.StatusForbidden, i18n.E("err.apiScope")))
104
return
105
}
106
ctx := context.WithValue(r.Context(), ctxKey{}, principal{User: actor.User, OK: true})
107
ctx = context.WithValue(ctx, actorKey{}, actor)
108
rt.Handler(s, w, r.WithContext(ctx))
109
}
110
111
func tokenFrom(r *http.Request) string {
112
if t := strings.TrimSpace(r.Header.Get("PRIVATE-TOKEN")); t != "" {
113
return t
114
}
115
if t := bearer(r); t != "" {
116
return t
117
}
118
_, pass, ok := r.BasicAuth()
119
if ok {
120
return pass
121
}
122
return ""
123
}
124
125
func apiUser(r *http.Request) store.User {
126
a, _ := r.Context().Value(actorKey{}).(apiActor)
127
return a.User
128
}
129
130
func readJSON(r *http.Request, dst any) error {
131
if r.Body == nil {
132
return nil
133
}
134
dec := json.NewDecoder(io.LimitReader(r.Body, 1<<20))
135
err := dec.Decode(dst)
136
if err == io.EOF {
137
return nil
138
}
139
return err
140
}
141
142
func writeJSON(w http.ResponseWriter, status int, v any) {
143
if status == http.StatusNoContent {
144
w.WriteHeader(status)
145
return
146
}
147
w.Header().Set("Content-Type", "application/json; charset=utf-8")
148
w.WriteHeader(status)
149
_ = json.NewEncoder(w).Encode(v)
150
}
151
152
func (s *Server) writeAPIErr(w http.ResponseWriter, r *http.Request, err error) {
153
writeJSON(w, statusOf(err), map[string]any{"message": s.trErr(r, err)})
154
}
155
156
func (s *Server) apiOK(w http.ResponseWriter, r *http.Request, err error) bool {
157
if err == nil {
158
return true
159
}
160
s.writeAPIErr(w, r, err)
161
return false
162
}
163
164
func pageQuery(r *http.Request) (page, per int) {
165
page, _ = strconv.Atoi(r.URL.Query().Get("page"))
166
per, _ = strconv.Atoi(r.URL.Query().Get("per_page"))
167
if page < 1 {
168
page = 1
169
}
170
if per < 1 {
171
per = 20
172
}
173
if per > 100 {
174
per = 100
175
}
176
return page, per
177
}
178
179
func writePage(w http.ResponseWriter, r *http.Request, items any, total, page, per int) {
180
w.Header().Set("X-Total", strconv.Itoa(total))
181
w.Header().Set("X-Page", strconv.Itoa(page))
182
w.Header().Set("X-Per-Page", strconv.Itoa(per))
183
next := ""
184
if page*per < total {
185
next = strconv.Itoa(page + 1)
186
}
187
w.Header().Set("X-Next-Page", next)
188
writeJSON(w, http.StatusOK, items)
189
}
190
191
func slicePage[T any](items []T, page, per int) []T {
192
if items == nil {
193
items = []T{}
194
}
195
start := (page - 1) * per
196
if start > len(items) {
197
start = len(items)
198
}
199
end := start + per
200
if end > len(items) {
201
end = len(items)
202
}
203
out := items[start:end]
204
if out == nil {
205
out = []T{}
206
}
207
return out
208
}
209
210
// CallAPI voert een API-verzoek uit als deze gebruiker, zonder cookie.
211
// SSH gebruikt hetzelfde pad als een toegangstoken met scope api.
212
func (s *Server) CallAPI(ctx context.Context, user store.User, method, path string, body []byte) (int, []byte) {
213
if !strings.HasPrefix(path, "/") {
214
path = "/" + path
215
}
216
if !strings.HasPrefix(path, "/api/") {
217
path = "/api/v1" + path
218
}
219
var rdr io.Reader = http.NoBody
220
if len(body) > 0 {
221
rdr = bytes.NewReader(body)
222
}
223
req := httptest.NewRequest(method, path, rdr).WithContext(context.WithValue(ctx, actorKey{}, apiActor{
224
User: user, Scopes: access.AllScopes(), Via: "ssh",
225
}))
226
req.Header.Set("Content-Type", "application/json")
227
rec := httptest.NewRecorder()
228
s.Handler().ServeHTTP(rec, req)
229
return rec.Code, rec.Body.Bytes()
230
}
231
232
func (s *Server) openAPI(w http.ResponseWriter, r *http.Request) {
233
writeJSON(w, http.StatusOK, openAPIDoc())
234
}
235
236
func openAPIDoc() map[string]any {
237
paths := map[string]map[string]any{}
238
for _, rt := range apiCatalog {
239
rel := strings.TrimPrefix(rt.Path, "/api/v1")
240
rel = openAPIPath(rel)
241
item := paths[rel]
242
if item == nil {
243
item = map[string]any{}
244
paths[rel] = item
245
}
246
op := map[string]any{
247
"summary": rt.Summary,
248
"responses": map[string]any{"200": map[string]any{"description": "OK"}, "default": map[string]any{"description": "Error", "content": map[string]any{"application/json": map[string]any{"schema": map[string]any{"$ref": "#/components/schemas/Error"}}}}},
249
}
250
if rt.Auth != authPublic {
251
op["security"] = []any{
252
map[string]any{"bearer": []any{}},
253
map[string]any{"privateToken": []any{}},
254
map[string]any{"basic": []any{}},
255
}
256
}
257
item[strings.ToLower(rt.Method)] = op
258
}
259
paths["/openapi.json"] = map[string]any{
260
"get": map[string]any{"summary": "OpenAPI document", "responses": map[string]any{"200": map[string]any{"description": "OK"}}},
261
}
262
out := map[string]any{}
263
for k, v := range paths {
264
out[k] = v
265
}
266
return map[string]any{
267
"openapi": "3.0.3",
268
"info": map[string]any{"title": "BlueGit", "version": "v1"},
269
"servers": []any{map[string]any{"url": "/api/v1"}},
270
"paths": out,
271
"components": map[string]any{
272
"securitySchemes": map[string]any{
273
"bearer": map[string]any{"type": "http", "scheme": "bearer"},
274
"privateToken": map[string]any{"type": "apiKey", "in": "header", "name": "PRIVATE-TOKEN"},
275
"basic": map[string]any{"type": "http", "scheme": "basic"},
276
},
277
"schemas": map[string]any{
278
"Error": map[string]any{"type": "object", "properties": map[string]any{"message": map[string]any{"type": "string"}}},
279
},
280
},
281
}
282
}
283
284
func openAPIPath(p string) string {
285
var b strings.Builder
286
for i := 0; i < len(p); i++ {
287
if p[i] == '{' {
288
j := strings.IndexByte(p[i:], '}')
289
if j < 0 {
290
b.WriteByte(p[i])
291
continue
292
}
293
name := p[i+1 : i+j]
294
name = strings.TrimSuffix(name, "...")
295
b.WriteByte('{')
296
b.WriteString(name)
297
b.WriteByte('}')
298
i += j
299
continue
300
}
301
b.WriteByte(p[i])
302
}
303
return b.String()
304
}
305
306
func apiIndex() []byte {
307
type row struct {
308
Method string `json:"method"`
309
Path string `json:"path"`
310
Summary string `json:"summary"`
311
Auth string `json:"auth"`
312
}
313
routes := []row{{Method: http.MethodGet, Path: "/api/v1/openapi.json", Summary: "OpenAPI document", Auth: "public"}}
314
for _, rt := range apiCatalog {
315
auth := "token"
316
if rt.Auth == authPublic {
317
auth = "public"
318
}
319
if rt.Auth == authRelease {
320
auth = "token_or_job"
321
}
322
routes = append(routes, row{Method: rt.Method, Path: rt.Path, Summary: rt.Summary, Auth: auth})
323
}
324
raw, _ := json.Marshal(map[string]any{
325
"openapi": "/api/v1/openapi.json",
326
"auth": []string{"Authorization: Bearer", "PRIVATE-TOKEN", "HTTP basic"},
327
"scopes": []string{access.ScopeAPI, access.ScopeReadAPI, access.ScopeReadRepo, access.ScopeWriteRepo},
328
"ssh": "ssh git@host api METHOD /api/v1/... ",
329
"routes": routes,
330
})
331
return raw
332
}
@@ -0,0 +1,332 @@1
package server2
3
import (4
"bytes"5
"context"6
"encoding/json"7
"io"8
"net/http"9
"net/http/httptest"10
"strconv"11
"strings"12
13
"gitlab.com/Timfa/bluegit/internal/access"14
"gitlab.com/Timfa/bluegit/internal/i18n"15
"gitlab.com/Timfa/bluegit/internal/store"16
)17
18
type actorKey struct{}19
20
type apiActor struct {21
User store.User22
Scopes access.Scopes23
Via string24
}25
26
type apiAuth int27
28
const (29
authUser apiAuth = iota30
authPublic31
authRelease32
)33
34
type apiHandler func(*Server, http.ResponseWriter, *http.Request)35
36
type apiRoute struct {37
Method string38
Path string39
Class access.ScopeClass40
Auth apiAuth41
Summary string42
Handler apiHandler43
}44
45
// apiRouteTaken zegt of server.go die methode en dat pad al registreert.46
// ServeMux weigert hetzelfde patroon twee keer. De expliciete handlers47
// blijven, de catalogus noemt het pad nog voor OpenAPI.48
func apiRouteTaken(method, path string) bool {49
switch method + " " + path {50
case "POST /api/v1/repos/{owner}/{repo}/releases",51
"GET /api/v1/groups/{path}/secrets",52
"POST /api/v1/groups/{path}/secrets",53
"DELETE /api/v1/groups/{path}/secrets/{name}":54
return true55
default:56
return false57
}58
}59
60
func (s *Server) mountAPI(mux *http.ServeMux) {61
mux.HandleFunc("GET /api/v1/openapi.json", func(w http.ResponseWriter, r *http.Request) {62
s.serveAPI(w, r, apiRoute{Method: http.MethodGet, Path: "/api/v1/openapi.json", Class: access.ScopePublic, Auth: authPublic, Summary: "OpenAPI document", Handler: (*Server).openAPI})63
})64
for _, rt := range apiCatalog {65
rt := rt66
if apiRouteTaken(rt.Method, rt.Path) {67
continue68
}69
mux.HandleFunc(rt.Method+" "+rt.Path, func(w http.ResponseWriter, r *http.Request) {70
s.serveAPI(w, r, rt)71
})72
}73
}74
75
func (s *Server) serveAPI(w http.ResponseWriter, r *http.Request, rt apiRoute) {76
w.Header().Set("Cache-Control", "no-store")77
if rt.Auth == authPublic {78
rt.Handler(s, w, r)79
return80
}81
if rt.Auth == authRelease {82
tok := tokenFrom(r)83
if strings.HasPrefix(tok, "bgj_") {84
rt.Handler(s, w, r)85
return86
}87
}88
actor, ok := r.Context().Value(actorKey{}).(apiActor)89
if !ok {90
tok := tokenFrom(r)91
if tok == "" || !strings.HasPrefix(tok, "bg_") {92
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, i18n.E("err.apiAuth")))93
return94
}95
auth, err := s.Store.AuthenticateToken(r.Context(), tok)96
if err != nil {97
s.writeAPIErr(w, r, fail(http.StatusUnauthorized, err))98
return99
}100
actor = apiActor{User: auth.User, Scopes: access.StoredScopes(auth.Token.Scopes), Via: "token"}101
}102
if !actor.Scopes.Allows(rt.Class) {103
s.writeAPIErr(w, r, fail(http.StatusForbidden, i18n.E("err.apiScope")))104
return105
}106
ctx := context.WithValue(r.Context(), ctxKey{}, principal{User: actor.User, OK: true})107
ctx = context.WithValue(ctx, actorKey{}, actor)108
rt.Handler(s, w, r.WithContext(ctx))109
}110
111
func tokenFrom(r *http.Request) string {112
if t := strings.TrimSpace(r.Header.Get("PRIVATE-TOKEN")); t != "" {113
return t114
}115
if t := bearer(r); t != "" {116
return t117
}118
_, pass, ok := r.BasicAuth()119
if ok {120
return pass121
}122
return ""123
}124
125
func apiUser(r *http.Request) store.User {126
a, _ := r.Context().Value(actorKey{}).(apiActor)127
return a.User128
}129
130
func readJSON(r *http.Request, dst any) error {131
if r.Body == nil {132
return nil133
}134
dec := json.NewDecoder(io.LimitReader(r.Body, 1<<20))135
err := dec.Decode(dst)136
if err == io.EOF {137
return nil138
}139
return err140
}141
142
func writeJSON(w http.ResponseWriter, status int, v any) {143
if status == http.StatusNoContent {144
w.WriteHeader(status)145
return146
}147
w.Header().Set("Content-Type", "application/json; charset=utf-8")148
w.WriteHeader(status)149
_ = json.NewEncoder(w).Encode(v)150
}151
152
func (s *Server) writeAPIErr(w http.ResponseWriter, r *http.Request, err error) {153
writeJSON(w, statusOf(err), map[string]any{"message": s.trErr(r, err)})154
}155
156
func (s *Server) apiOK(w http.ResponseWriter, r *http.Request, err error) bool {157
if err == nil {158
return true159
}160
s.writeAPIErr(w, r, err)161
return false162
}163
164
func pageQuery(r *http.Request) (page, per int) {165
page, _ = strconv.Atoi(r.URL.Query().Get("page"))166
per, _ = strconv.Atoi(r.URL.Query().Get("per_page"))167
if page < 1 {168
page = 1169
}170
if per < 1 {171
per = 20172
}173
if per > 100 {174
per = 100175
}176
return page, per177
}178
179
func writePage(w http.ResponseWriter, r *http.Request, items any, total, page, per int) {180
w.Header().Set("X-Total", strconv.Itoa(total))181
w.Header().Set("X-Page", strconv.Itoa(page))182
w.Header().Set("X-Per-Page", strconv.Itoa(per))183
next := ""184
if page*per < total {185
next = strconv.Itoa(page + 1)186
}187
w.Header().Set("X-Next-Page", next)188
writeJSON(w, http.StatusOK, items)189
}190
191
func slicePage[T any](items []T, page, per int) []T {192
if items == nil {193
items = []T{}194
}195
start := (page - 1) * per196
if start > len(items) {197
start = len(items)198
}199
end := start + per200
if end > len(items) {201
end = len(items)202
}203
out := items[start:end]204
if out == nil {205
out = []T{}206
}207
return out208
}209
210
// CallAPI voert een API-verzoek uit als deze gebruiker, zonder cookie.211
// SSH gebruikt hetzelfde pad als een toegangstoken met scope api.212
func (s *Server) CallAPI(ctx context.Context, user store.User, method, path string, body []byte) (int, []byte) {213
if !strings.HasPrefix(path, "/") {214
path = "/" + path215
}216
if !strings.HasPrefix(path, "/api/") {217
path = "/api/v1" + path218
}219
var rdr io.Reader = http.NoBody220
if len(body) > 0 {221
rdr = bytes.NewReader(body)222
}223
req := httptest.NewRequest(method, path, rdr).WithContext(context.WithValue(ctx, actorKey{}, apiActor{224
User: user, Scopes: access.AllScopes(), Via: "ssh",225
}))226
req.Header.Set("Content-Type", "application/json")227
rec := httptest.NewRecorder()228
s.Handler().ServeHTTP(rec, req)229
return rec.Code, rec.Body.Bytes()230
}231
232
func (s *Server) openAPI(w http.ResponseWriter, r *http.Request) {233
writeJSON(w, http.StatusOK, openAPIDoc())234
}235
236
func openAPIDoc() map[string]any {237
paths := map[string]map[string]any{}238
for _, rt := range apiCatalog {239
rel := strings.TrimPrefix(rt.Path, "/api/v1")240
rel = openAPIPath(rel)241
item := paths[rel]242
if item == nil {243
item = map[string]any{}244
paths[rel] = item245
}246
op := map[string]any{247
"summary": rt.Summary,248
"responses": map[string]any{"200": map[string]any{"description": "OK"}, "default": map[string]any{"description": "Error", "content": map[string]any{"application/json": map[string]any{"schema": map[string]any{"$ref": "#/components/schemas/Error"}}}}},249
}250
if rt.Auth != authPublic {251
op["security"] = []any{252
map[string]any{"bearer": []any{}},253
map[string]any{"privateToken": []any{}},254
map[string]any{"basic": []any{}},255
}256
}257
item[strings.ToLower(rt.Method)] = op258
}259
paths["/openapi.json"] = map[string]any{260
"get": map[string]any{"summary": "OpenAPI document", "responses": map[string]any{"200": map[string]any{"description": "OK"}}},261
}262
out := map[string]any{}263
for k, v := range paths {264
out[k] = v265
}266
return map[string]any{267
"openapi": "3.0.3",268
"info": map[string]any{"title": "BlueGit", "version": "v1"},269
"servers": []any{map[string]any{"url": "/api/v1"}},270
"paths": out,271
"components": map[string]any{272
"securitySchemes": map[string]any{273
"bearer": map[string]any{"type": "http", "scheme": "bearer"},274
"privateToken": map[string]any{"type": "apiKey", "in": "header", "name": "PRIVATE-TOKEN"},275
"basic": map[string]any{"type": "http", "scheme": "basic"},276
},277
"schemas": map[string]any{278
"Error": map[string]any{"type": "object", "properties": map[string]any{"message": map[string]any{"type": "string"}}},279
},280
},281
}282
}283
284
func openAPIPath(p string) string {285
var b strings.Builder286
for i := 0; i < len(p); i++ {287
if p[i] == '{' {288
j := strings.IndexByte(p[i:], '}')289
if j < 0 {290
b.WriteByte(p[i])291
continue292
}293
name := p[i+1 : i+j]294
name = strings.TrimSuffix(name, "...")295
b.WriteByte('{')296
b.WriteString(name)297
b.WriteByte('}')298
i += j299
continue300
}301
b.WriteByte(p[i])302
}303
return b.String()304
}305
306
func apiIndex() []byte {307
type row struct {308
Method string `json:"method"`309
Path string `json:"path"`310
Summary string `json:"summary"`311
Auth string `json:"auth"`312
}313
routes := []row{{Method: http.MethodGet, Path: "/api/v1/openapi.json", Summary: "OpenAPI document", Auth: "public"}}314
for _, rt := range apiCatalog {315
auth := "token"316
if rt.Auth == authPublic {317
auth = "public"318
}319
if rt.Auth == authRelease {320
auth = "token_or_job"321
}322
routes = append(routes, row{Method: rt.Method, Path: rt.Path, Summary: rt.Summary, Auth: auth})323
}324
raw, _ := json.Marshal(map[string]any{325
"openapi": "/api/v1/openapi.json",326
"auth": []string{"Authorization: Bearer", "PRIVATE-TOKEN", "HTTP basic"},327
"scopes": []string{access.ScopeAPI, access.ScopeReadAPI, access.ScopeReadRepo, access.ScopeWriteRepo},328
"ssh": "ssh git@host api METHOD /api/v1/... ",329
"routes": routes,330
})331
return raw332
}@@ -0,0 +1,121 @@
1
package server
2
3
import (
4
"net/http"
5
6
"gitlab.com/Timfa/bluegit/internal/access"
7
)
8
9
var apiCatalog = []apiRoute{
10
{http.MethodGet, "/api/v1/ci/spec", access.ScopePublic, authPublic, "CI specification", (*Server).ciSpec},
11
{http.MethodGet, "/api/v1/ci/presets", access.ScopePublic, authPublic, "CI image presets", (*Server).apiPresets},
12
13
{http.MethodGet, "/api/v1/user", access.ScopeRead, authUser, "Current user", (*Server).apiGetUser},
14
{http.MethodPut, "/api/v1/user", access.ScopeWrite, authUser, "Update profile language", (*Server).apiPutUser},
15
{http.MethodGet, "/api/v1/user/export", access.ScopeRead, authUser, "Export account", (*Server).apiExport},
16
{http.MethodGet, "/api/v1/users/{username}", access.ScopeRead, authUser, "User profile", (*Server).apiUserByName},
17
{http.MethodGet, "/api/v1/user/tokens", access.ScopeRead, authUser, "List access tokens", (*Server).apiListTokens},
18
{http.MethodPost, "/api/v1/user/tokens", access.ScopeWrite, authUser, "Create access token", (*Server).apiCreateToken},
19
{http.MethodDelete, "/api/v1/user/tokens/{id}", access.ScopeWrite, authUser, "Revoke access token", (*Server).apiDeleteToken},
20
{http.MethodGet, "/api/v1/user/keys", access.ScopeRead, authUser, "List SSH keys", (*Server).apiListKeys},
21
{http.MethodPost, "/api/v1/user/keys", access.ScopeWrite, authUser, "Add SSH key", (*Server).apiAddKey},
22
{http.MethodDelete, "/api/v1/user/keys/{id}", access.ScopeWrite, authUser, "Remove SSH key", (*Server).apiDeleteKey},
23
24
{http.MethodGet, "/api/v1/groups", access.ScopeRead, authUser, "List groups", (*Server).apiListGroups},
25
{http.MethodPost, "/api/v1/groups", access.ScopeWrite, authUser, "Create group", (*Server).apiCreateGroup},
26
{http.MethodGet, "/api/v1/groups/{path}", access.ScopeRead, authUser, "Get group", (*Server).apiGetGroup},
27
{http.MethodPut, "/api/v1/groups/{path}", access.ScopeWrite, authUser, "Update group", (*Server).apiPutGroup},
28
{http.MethodPost, "/api/v1/groups/{path}/transfer", access.ScopeWrite, authUser, "Transfer group owner", (*Server).apiTransferGroup},
29
{http.MethodGet, "/api/v1/groups/{path}/projects", access.ScopeRead, authUser, "List group projects", (*Server).apiGroupProjects},
30
{http.MethodGet, "/api/v1/groups/{path}/members", access.ScopeRead, authUser, "List group members", (*Server).apiGroupMembers},
31
{http.MethodPost, "/api/v1/groups/{path}/members", access.ScopeWrite, authUser, "Add group member", (*Server).apiGroupMembers},
32
{http.MethodDelete, "/api/v1/groups/{path}/members/{username}", access.ScopeWrite, authUser, "Remove group member", (*Server).apiDeleteGroupMember},
33
{http.MethodGet, "/api/v1/groups/{path}/secrets", access.ScopeRead, authUser, "List group secrets", (*Server).apiGroupSecrets},
34
{http.MethodPost, "/api/v1/groups/{path}/secrets", access.ScopeWrite, authUser, "Set group secret", (*Server).apiGroupSecrets},
35
{http.MethodDelete, "/api/v1/groups/{path}/secrets/{name}", access.ScopeWrite, authUser, "Delete group secret", (*Server).apiDeleteGroupSecret},
36
{http.MethodGet, "/api/v1/groups/{path}/webhooks", access.ScopeRead, authUser, "List group webhooks", (*Server).apiGroupHooks},
37
{http.MethodPost, "/api/v1/groups/{path}/webhooks", access.ScopeWrite, authUser, "Create group webhook", (*Server).apiGroupHooks},
38
{http.MethodDelete, "/api/v1/groups/{path}/webhooks/{id}", access.ScopeWrite, authUser, "Delete group webhook", (*Server).apiDeleteGroupHook},
39
{http.MethodGet, "/api/v1/groups/{path}/approvals", access.ScopeRead, authUser, "Get group approvals", (*Server).apiGroupApproval},
40
{http.MethodPut, "/api/v1/groups/{path}/approvals", access.ScopeWrite, authUser, "Save group approvals", (*Server).apiGroupApproval},
41
{http.MethodGet, "/api/v1/groups/{path}/logo", access.ScopeRead, authUser, "Group logo", (*Server).apiGroupLogo},
42
{http.MethodPost, "/api/v1/groups/{path}/logo", access.ScopeWrite, authUser, "Upload group logo", (*Server).apiGroupLogo},
43
44
{http.MethodGet, "/api/v1/projects", access.ScopeRead, authUser, "List projects", (*Server).apiListProjects},
45
{http.MethodPost, "/api/v1/projects", access.ScopeWrite, authUser, "Create project", (*Server).apiCreateProject},
46
{http.MethodGet, "/api/v1/projects/{owner}/{repo}", access.ScopeRepoRead, authUser, "Get project", (*Server).apiGetProject},
47
{http.MethodPut, "/api/v1/projects/{owner}/{repo}", access.ScopeWrite, authUser, "Update project", (*Server).apiPutProject},
48
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}", access.ScopeWrite, authUser, "Delete project", (*Server).apiDeleteProject},
49
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/star", access.ScopeWrite, authUser, "Toggle star", (*Server).apiStar},
50
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/logo", access.ScopeRepoRead, authUser, "Project logo", (*Server).apiProjectLogo},
51
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/logo", access.ScopeWrite, authUser, "Upload project logo", (*Server).apiProjectLogo},
52
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/members", access.ScopeRead, authUser, "List project members", (*Server).apiProjectMembers},
53
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/members", access.ScopeWrite, authUser, "Add project member", (*Server).apiProjectMembers},
54
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/members/{username}", access.ScopeWrite, authUser, "Remove project member", (*Server).apiDeleteProjectMember},
55
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/secrets", access.ScopeRead, authUser, "List project secrets", (*Server).apiProjectSecrets},
56
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/secrets", access.ScopeWrite, authUser, "Set project secret", (*Server).apiProjectSecrets},
57
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/secrets/{name}", access.ScopeWrite, authUser, "Delete project secret", (*Server).apiDeleteProjectSecret},
58
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/webhooks", access.ScopeRead, authUser, "List project webhooks", (*Server).apiProjectHooks},
59
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/webhooks", access.ScopeWrite, authUser, "Create project webhook", (*Server).apiProjectHooks},
60
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/webhooks/{id}", access.ScopeWrite, authUser, "Delete project webhook", (*Server).apiDeleteProjectHook},
61
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/approvals", access.ScopeRead, authUser, "Get project approvals", (*Server).apiProjectApproval},
62
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/approvals", access.ScopeWrite, authUser, "Save project approvals", (*Server).apiProjectApproval},
63
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/protected_branches", access.ScopeRead, authUser, "List protected branches", (*Server).apiProtectBranches},
64
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/protected_branches", access.ScopeWrite, authUser, "Protect branch pattern", (*Server).apiProtectBranches},
65
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/protected_branches/{pattern...}", access.ScopeWrite, authUser, "Unprotect branch pattern", (*Server).apiUnprotectBranch},
66
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/protected_tags", access.ScopeRead, authUser, "List protected tags", (*Server).apiProtectTags},
67
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/protected_tags", access.ScopeWrite, authUser, "Protect tag pattern", (*Server).apiProtectTags},
68
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/protected_tags/{pattern...}", access.ScopeWrite, authUser, "Unprotect tag pattern", (*Server).apiUnprotectTag},
69
70
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/branches", access.ScopeRepoRead, authUser, "List branches", (*Server).apiBranches},
71
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/repository/branches", access.ScopeRepoWrite, authUser, "Create branch", (*Server).apiBranches},
72
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/repository/branches/{branch...}", access.ScopeRepoWrite, authUser, "Rename branch", (*Server).apiBranch},
73
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/repository/branches/{branch...}", access.ScopeRepoWrite, authUser, "Delete branch", (*Server).apiBranch},
74
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/tags", access.ScopeRepoRead, authUser, "List tags", (*Server).apiTags},
75
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/repository/tags", access.ScopeRepoWrite, authUser, "Create tag", (*Server).apiTags},
76
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/repository/tags/{tag}", access.ScopeRepoWrite, authUser, "Delete tag", (*Server).apiDeleteTag},
77
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/tags/{tag}/archive", access.ScopeRepoRead, authUser, "Download tag archive", (*Server).apiTagArchive},
78
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/tree", access.ScopeRepoRead, authUser, "List tree", (*Server).apiTree},
79
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/files/{path...}", access.ScopeRepoRead, authUser, "Read file", (*Server).apiFile},
80
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/commits", access.ScopeRepoRead, authUser, "List commits", (*Server).apiCommits},
81
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/repository/commits", access.ScopeRepoWrite, authUser, "Create commit", (*Server).apiCommits},
82
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/commits/{sha}", access.ScopeRepoRead, authUser, "Get commit", (*Server).apiCommit},
83
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/commits/{sha}/diff", access.ScopeRepoRead, authUser, "Commit diff", (*Server).apiCommitDiff},
84
85
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/merge_requests", access.ScopeRead, authUser, "List merge requests", (*Server).apiMRs},
86
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests", access.ScopeWrite, authUser, "Create merge request", (*Server).apiMRs},
87
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}", access.ScopeRead, authUser, "Get merge request", (*Server).apiMR},
88
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}", access.ScopeWrite, authUser, "Update merge request", (*Server).apiMR},
89
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/notes", access.ScopeRead, authUser, "List notes", (*Server).apiMRNotes},
90
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/notes", access.ScopeWrite, authUser, "Create note", (*Server).apiMRNotes},
91
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/reviews", access.ScopeWrite, authUser, "Submit review", (*Server).apiReview},
92
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/reviews/dismiss", access.ScopeWrite, authUser, "Dismiss review", (*Server).apiDismissReview},
93
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/suggestions", access.ScopeRepoWrite, authUser, "Apply suggestions", (*Server).apiSuggestions},
94
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/merge", access.ScopeRepoWrite, authUser, "Merge merge request", (*Server).apiMerge},
95
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/close", access.ScopeWrite, authUser, "Close merge request", (*Server).apiCloseMR},
96
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/reopen", access.ScopeWrite, authUser, "Reopen merge request", (*Server).apiReopenMR},
97
98
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines", access.ScopeRead, authUser, "List pipelines", (*Server).apiPipelines},
99
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines", access.ScopeWrite, authUser, "Start pipeline", (*Server).apiPipelines},
100
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}", access.ScopeRead, authUser, "Get pipeline", (*Server).apiPipeline},
101
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/cancel", access.ScopeWrite, authUser, "Cancel pipeline", (*Server).apiCancelPipeline},
102
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs", access.ScopeRead, authUser, "List jobs", (*Server).apiJobs},
103
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}", access.ScopeRead, authUser, "Get job", (*Server).apiJob},
104
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/log", access.ScopeRead, authUser, "Job log", (*Server).apiJobLog},
105
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/play", access.ScopeWrite, authUser, "Play manual job", (*Server).apiPlayJob},
106
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/retry", access.ScopeWrite, authUser, "Retry job", (*Server).apiRetryJob},
107
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/cancel", access.ScopeWrite, authUser, "Cancel job", (*Server).apiCancelJob},
108
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/artifacts", access.ScopeRead, authUser, "List artifacts", (*Server).apiArtifacts},
109
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/artifacts/{path...}", access.ScopeRead, authUser, "Download artifact", (*Server).apiArtifact},
110
111
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/ci/file", access.ScopeRepoRead, authUser, "Read CI file", (*Server).apiCIFile},
112
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/ci/file", access.ScopeRepoWrite, authUser, "Save CI file", (*Server).apiCIFile},
113
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/ci/lint", access.ScopeRead, authUser, "Lint CI file", (*Server).apiLintCI},
114
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/releases", access.ScopeRead, authUser, "List releases", (*Server).apiReleases},
115
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/releases", access.ScopeWrite, authUser, "Publish release", (*Server).createRelease},
116
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/releases/{tag}/assets/{name}", access.ScopeRead, authUser, "Download release asset", (*Server).apiReleaseAsset},
117
{http.MethodPost, "/api/v1/repos/{owner}/{repo}/releases", access.ScopeWrite, authRelease, "Publish release from a job or user token", (*Server).createRelease},
118
119
{http.MethodGet, "/api/v1/admin/storage", access.ScopeAdmin, authUser, "Read instance storage", (*Server).apiAdminStorage},
120
{http.MethodPut, "/api/v1/admin/storage", access.ScopeAdmin, authUser, "Set instance storage", (*Server).apiAdminStorage},
121
}
@@ -0,0 +1,121 @@1
package server2
3
import (4
"net/http"5
6
"gitlab.com/Timfa/bluegit/internal/access"7
)8
9
var apiCatalog = []apiRoute{10
{http.MethodGet, "/api/v1/ci/spec", access.ScopePublic, authPublic, "CI specification", (*Server).ciSpec},11
{http.MethodGet, "/api/v1/ci/presets", access.ScopePublic, authPublic, "CI image presets", (*Server).apiPresets},12
13
{http.MethodGet, "/api/v1/user", access.ScopeRead, authUser, "Current user", (*Server).apiGetUser},14
{http.MethodPut, "/api/v1/user", access.ScopeWrite, authUser, "Update profile language", (*Server).apiPutUser},15
{http.MethodGet, "/api/v1/user/export", access.ScopeRead, authUser, "Export account", (*Server).apiExport},16
{http.MethodGet, "/api/v1/users/{username}", access.ScopeRead, authUser, "User profile", (*Server).apiUserByName},17
{http.MethodGet, "/api/v1/user/tokens", access.ScopeRead, authUser, "List access tokens", (*Server).apiListTokens},18
{http.MethodPost, "/api/v1/user/tokens", access.ScopeWrite, authUser, "Create access token", (*Server).apiCreateToken},19
{http.MethodDelete, "/api/v1/user/tokens/{id}", access.ScopeWrite, authUser, "Revoke access token", (*Server).apiDeleteToken},20
{http.MethodGet, "/api/v1/user/keys", access.ScopeRead, authUser, "List SSH keys", (*Server).apiListKeys},21
{http.MethodPost, "/api/v1/user/keys", access.ScopeWrite, authUser, "Add SSH key", (*Server).apiAddKey},22
{http.MethodDelete, "/api/v1/user/keys/{id}", access.ScopeWrite, authUser, "Remove SSH key", (*Server).apiDeleteKey},23
24
{http.MethodGet, "/api/v1/groups", access.ScopeRead, authUser, "List groups", (*Server).apiListGroups},25
{http.MethodPost, "/api/v1/groups", access.ScopeWrite, authUser, "Create group", (*Server).apiCreateGroup},26
{http.MethodGet, "/api/v1/groups/{path}", access.ScopeRead, authUser, "Get group", (*Server).apiGetGroup},27
{http.MethodPut, "/api/v1/groups/{path}", access.ScopeWrite, authUser, "Update group", (*Server).apiPutGroup},28
{http.MethodPost, "/api/v1/groups/{path}/transfer", access.ScopeWrite, authUser, "Transfer group owner", (*Server).apiTransferGroup},29
{http.MethodGet, "/api/v1/groups/{path}/projects", access.ScopeRead, authUser, "List group projects", (*Server).apiGroupProjects},30
{http.MethodGet, "/api/v1/groups/{path}/members", access.ScopeRead, authUser, "List group members", (*Server).apiGroupMembers},31
{http.MethodPost, "/api/v1/groups/{path}/members", access.ScopeWrite, authUser, "Add group member", (*Server).apiGroupMembers},32
{http.MethodDelete, "/api/v1/groups/{path}/members/{username}", access.ScopeWrite, authUser, "Remove group member", (*Server).apiDeleteGroupMember},33
{http.MethodGet, "/api/v1/groups/{path}/secrets", access.ScopeRead, authUser, "List group secrets", (*Server).apiGroupSecrets},34
{http.MethodPost, "/api/v1/groups/{path}/secrets", access.ScopeWrite, authUser, "Set group secret", (*Server).apiGroupSecrets},35
{http.MethodDelete, "/api/v1/groups/{path}/secrets/{name}", access.ScopeWrite, authUser, "Delete group secret", (*Server).apiDeleteGroupSecret},36
{http.MethodGet, "/api/v1/groups/{path}/webhooks", access.ScopeRead, authUser, "List group webhooks", (*Server).apiGroupHooks},37
{http.MethodPost, "/api/v1/groups/{path}/webhooks", access.ScopeWrite, authUser, "Create group webhook", (*Server).apiGroupHooks},38
{http.MethodDelete, "/api/v1/groups/{path}/webhooks/{id}", access.ScopeWrite, authUser, "Delete group webhook", (*Server).apiDeleteGroupHook},39
{http.MethodGet, "/api/v1/groups/{path}/approvals", access.ScopeRead, authUser, "Get group approvals", (*Server).apiGroupApproval},40
{http.MethodPut, "/api/v1/groups/{path}/approvals", access.ScopeWrite, authUser, "Save group approvals", (*Server).apiGroupApproval},41
{http.MethodGet, "/api/v1/groups/{path}/logo", access.ScopeRead, authUser, "Group logo", (*Server).apiGroupLogo},42
{http.MethodPost, "/api/v1/groups/{path}/logo", access.ScopeWrite, authUser, "Upload group logo", (*Server).apiGroupLogo},43
44
{http.MethodGet, "/api/v1/projects", access.ScopeRead, authUser, "List projects", (*Server).apiListProjects},45
{http.MethodPost, "/api/v1/projects", access.ScopeWrite, authUser, "Create project", (*Server).apiCreateProject},46
{http.MethodGet, "/api/v1/projects/{owner}/{repo}", access.ScopeRepoRead, authUser, "Get project", (*Server).apiGetProject},47
{http.MethodPut, "/api/v1/projects/{owner}/{repo}", access.ScopeWrite, authUser, "Update project", (*Server).apiPutProject},48
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}", access.ScopeWrite, authUser, "Delete project", (*Server).apiDeleteProject},49
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/star", access.ScopeWrite, authUser, "Toggle star", (*Server).apiStar},50
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/logo", access.ScopeRepoRead, authUser, "Project logo", (*Server).apiProjectLogo},51
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/logo", access.ScopeWrite, authUser, "Upload project logo", (*Server).apiProjectLogo},52
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/members", access.ScopeRead, authUser, "List project members", (*Server).apiProjectMembers},53
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/members", access.ScopeWrite, authUser, "Add project member", (*Server).apiProjectMembers},54
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/members/{username}", access.ScopeWrite, authUser, "Remove project member", (*Server).apiDeleteProjectMember},55
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/secrets", access.ScopeRead, authUser, "List project secrets", (*Server).apiProjectSecrets},56
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/secrets", access.ScopeWrite, authUser, "Set project secret", (*Server).apiProjectSecrets},57
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/secrets/{name}", access.ScopeWrite, authUser, "Delete project secret", (*Server).apiDeleteProjectSecret},58
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/webhooks", access.ScopeRead, authUser, "List project webhooks", (*Server).apiProjectHooks},59
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/webhooks", access.ScopeWrite, authUser, "Create project webhook", (*Server).apiProjectHooks},60
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/webhooks/{id}", access.ScopeWrite, authUser, "Delete project webhook", (*Server).apiDeleteProjectHook},61
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/approvals", access.ScopeRead, authUser, "Get project approvals", (*Server).apiProjectApproval},62
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/approvals", access.ScopeWrite, authUser, "Save project approvals", (*Server).apiProjectApproval},63
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/protected_branches", access.ScopeRead, authUser, "List protected branches", (*Server).apiProtectBranches},64
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/protected_branches", access.ScopeWrite, authUser, "Protect branch pattern", (*Server).apiProtectBranches},65
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/protected_branches/{pattern...}", access.ScopeWrite, authUser, "Unprotect branch pattern", (*Server).apiUnprotectBranch},66
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/protected_tags", access.ScopeRead, authUser, "List protected tags", (*Server).apiProtectTags},67
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/protected_tags", access.ScopeWrite, authUser, "Protect tag pattern", (*Server).apiProtectTags},68
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/protected_tags/{pattern...}", access.ScopeWrite, authUser, "Unprotect tag pattern", (*Server).apiUnprotectTag},69
70
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/branches", access.ScopeRepoRead, authUser, "List branches", (*Server).apiBranches},71
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/repository/branches", access.ScopeRepoWrite, authUser, "Create branch", (*Server).apiBranches},72
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/repository/branches/{branch...}", access.ScopeRepoWrite, authUser, "Rename branch", (*Server).apiBranch},73
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/repository/branches/{branch...}", access.ScopeRepoWrite, authUser, "Delete branch", (*Server).apiBranch},74
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/tags", access.ScopeRepoRead, authUser, "List tags", (*Server).apiTags},75
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/repository/tags", access.ScopeRepoWrite, authUser, "Create tag", (*Server).apiTags},76
{http.MethodDelete, "/api/v1/projects/{owner}/{repo}/repository/tags/{tag}", access.ScopeRepoWrite, authUser, "Delete tag", (*Server).apiDeleteTag},77
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/tags/{tag}/archive", access.ScopeRepoRead, authUser, "Download tag archive", (*Server).apiTagArchive},78
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/tree", access.ScopeRepoRead, authUser, "List tree", (*Server).apiTree},79
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/files/{path...}", access.ScopeRepoRead, authUser, "Read file", (*Server).apiFile},80
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/commits", access.ScopeRepoRead, authUser, "List commits", (*Server).apiCommits},81
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/repository/commits", access.ScopeRepoWrite, authUser, "Create commit", (*Server).apiCommits},82
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/commits/{sha}", access.ScopeRepoRead, authUser, "Get commit", (*Server).apiCommit},83
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/repository/commits/{sha}/diff", access.ScopeRepoRead, authUser, "Commit diff", (*Server).apiCommitDiff},84
85
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/merge_requests", access.ScopeRead, authUser, "List merge requests", (*Server).apiMRs},86
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests", access.ScopeWrite, authUser, "Create merge request", (*Server).apiMRs},87
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}", access.ScopeRead, authUser, "Get merge request", (*Server).apiMR},88
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}", access.ScopeWrite, authUser, "Update merge request", (*Server).apiMR},89
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/notes", access.ScopeRead, authUser, "List notes", (*Server).apiMRNotes},90
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/notes", access.ScopeWrite, authUser, "Create note", (*Server).apiMRNotes},91
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/reviews", access.ScopeWrite, authUser, "Submit review", (*Server).apiReview},92
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/reviews/dismiss", access.ScopeWrite, authUser, "Dismiss review", (*Server).apiDismissReview},93
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/suggestions", access.ScopeRepoWrite, authUser, "Apply suggestions", (*Server).apiSuggestions},94
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/merge", access.ScopeRepoWrite, authUser, "Merge merge request", (*Server).apiMerge},95
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/close", access.ScopeWrite, authUser, "Close merge request", (*Server).apiCloseMR},96
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/merge_requests/{number}/reopen", access.ScopeWrite, authUser, "Reopen merge request", (*Server).apiReopenMR},97
98
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines", access.ScopeRead, authUser, "List pipelines", (*Server).apiPipelines},99
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines", access.ScopeWrite, authUser, "Start pipeline", (*Server).apiPipelines},100
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}", access.ScopeRead, authUser, "Get pipeline", (*Server).apiPipeline},101
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/cancel", access.ScopeWrite, authUser, "Cancel pipeline", (*Server).apiCancelPipeline},102
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs", access.ScopeRead, authUser, "List jobs", (*Server).apiJobs},103
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}", access.ScopeRead, authUser, "Get job", (*Server).apiJob},104
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/log", access.ScopeRead, authUser, "Job log", (*Server).apiJobLog},105
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/play", access.ScopeWrite, authUser, "Play manual job", (*Server).apiPlayJob},106
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/retry", access.ScopeWrite, authUser, "Retry job", (*Server).apiRetryJob},107
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/cancel", access.ScopeWrite, authUser, "Cancel job", (*Server).apiCancelJob},108
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/artifacts", access.ScopeRead, authUser, "List artifacts", (*Server).apiArtifacts},109
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/artifacts/{path...}", access.ScopeRead, authUser, "Download artifact", (*Server).apiArtifact},110
111
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/ci/file", access.ScopeRepoRead, authUser, "Read CI file", (*Server).apiCIFile},112
{http.MethodPut, "/api/v1/projects/{owner}/{repo}/ci/file", access.ScopeRepoWrite, authUser, "Save CI file", (*Server).apiCIFile},113
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/ci/lint", access.ScopeRead, authUser, "Lint CI file", (*Server).apiLintCI},114
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/releases", access.ScopeRead, authUser, "List releases", (*Server).apiReleases},115
{http.MethodPost, "/api/v1/projects/{owner}/{repo}/releases", access.ScopeWrite, authUser, "Publish release", (*Server).createRelease},116
{http.MethodGet, "/api/v1/projects/{owner}/{repo}/releases/{tag}/assets/{name}", access.ScopeRead, authUser, "Download release asset", (*Server).apiReleaseAsset},117
{http.MethodPost, "/api/v1/repos/{owner}/{repo}/releases", access.ScopeWrite, authRelease, "Publish release from a job or user token", (*Server).createRelease},118
119
{http.MethodGet, "/api/v1/admin/storage", access.ScopeAdmin, authUser, "Read instance storage", (*Server).apiAdminStorage},120
{http.MethodPut, "/api/v1/admin/storage", access.ScopeAdmin, authUser, "Set instance storage", (*Server).apiAdminStorage},121
}@@ -0,0 +1,290 @@
1
package server
2
3
import (
4
"context"
5
"encoding/json"
6
"net/http"
7
"net/http/httptest"
8
"os/exec"
9
"path/filepath"
10
"strings"
11
"testing"
12
"time"
13
14
"gitlab.com/Timfa/bluegit/internal/auth"
15
"gitlab.com/Timfa/bluegit/internal/config"
16
"gitlab.com/Timfa/bluegit/internal/store"
17
)
18
19
func TestAPICatalogCoversResources(t *testing.T) {
20
var b strings.Builder
21
b.WriteString("GET /api/v1/openapi.json\n")
22
for _, rt := range apiCatalog {
23
b.WriteString(rt.Method)
24
b.WriteByte(' ')
25
b.WriteString(rt.Path)
26
b.WriteByte('\n')
27
}
28
blob := b.String()
29
for _, want := range []string{
30
"GET /api/v1/user\n",
31
"PUT /api/v1/user\n",
32
"GET /api/v1/user/export\n",
33
"POST /api/v1/user/tokens\n",
34
"DELETE /api/v1/user/tokens/{id}\n",
35
"POST /api/v1/user/keys\n",
36
"POST /api/v1/groups\n",
37
"POST /api/v1/groups/{path}/transfer\n",
38
"POST /api/v1/groups/{path}/members\n",
39
"POST /api/v1/groups/{path}/secrets\n",
40
"POST /api/v1/groups/{path}/webhooks\n",
41
"PUT /api/v1/groups/{path}/approvals\n",
42
"POST /api/v1/groups/{path}/logo\n",
43
"POST /api/v1/projects\n",
44
"DELETE /api/v1/projects/{owner}/{repo}\n",
45
"POST /api/v1/projects/{owner}/{repo}/members\n",
46
"POST /api/v1/projects/{owner}/{repo}/protected_branches\n",
47
"POST /api/v1/projects/{owner}/{repo}/protected_tags\n",
48
"POST /api/v1/projects/{owner}/{repo}/repository/branches\n",
49
"DELETE /api/v1/projects/{owner}/{repo}/repository/branches/{branch...}\n",
50
"POST /api/v1/projects/{owner}/{repo}/repository/tags\n",
51
"GET /api/v1/projects/{owner}/{repo}/repository/files/{path...}\n",
52
"POST /api/v1/projects/{owner}/{repo}/repository/commits\n",
53
"GET /api/v1/projects/{owner}/{repo}/repository/commits/{sha}/diff\n",
54
"POST /api/v1/projects/{owner}/{repo}/merge_requests\n",
55
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/notes\n",
56
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/reviews\n",
57
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/suggestions\n",
58
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/merge\n",
59
"POST /api/v1/projects/{owner}/{repo}/pipelines\n",
60
"POST /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/play\n",
61
"POST /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/retry\n",
62
"POST /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/cancel\n",
63
"GET /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/log\n",
64
"GET /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/artifacts\n",
65
"PUT /api/v1/projects/{owner}/{repo}/ci/file\n",
66
"POST /api/v1/projects/{owner}/{repo}/ci/lint\n",
67
"GET /api/v1/ci/spec\n",
68
"GET /api/v1/ci/presets\n",
69
"POST /api/v1/projects/{owner}/{repo}/releases\n",
70
"POST /api/v1/repos/{owner}/{repo}/releases\n",
71
"PUT /api/v1/admin/storage\n",
72
} {
73
if !strings.Contains(blob, want) {
74
t.Errorf("catalog mist %s", strings.TrimSpace(want))
75
}
76
}
77
}
78
79
func TestAPIPermissionsAndResources(t *testing.T) {
80
if _, err := exec.LookPath("git"); err != nil {
81
t.Skip("git ontbreekt")
82
}
83
storage := t.TempDir()
84
st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
85
if err != nil {
86
t.Fatal(err)
87
}
88
t.Cleanup(func() { _ = st.Close() })
89
ctx := context.Background()
90
ada, err := st.UpsertUser(ctx, 1, "ada", "", false)
91
if err != nil || !ada.InstanceAdmin {
92
t.Fatalf("ada admin: %+v %v", ada, err)
93
}
94
dev, err := st.UpsertUser(ctx, 2, "dev", "", false)
95
if err != nil {
96
t.Fatal(err)
97
}
98
ro, err := st.UpsertUser(ctx, 3, "ro", "", false)
99
if err != nil {
100
t.Fatal(err)
101
}
102
issue := func(u store.User, name, scopes string, exp time.Time) string {
103
t.Helper()
104
plain, _, err := st.IssueToken(ctx, u.ID, store.TokenRequest{Name: name, Scopes: scopes, ExpiresAt: exp})
105
if err != nil {
106
t.Fatal(err)
107
}
108
return plain
109
}
110
adaTok := issue(ada, "ada", "api", time.Time{})
111
devTok := issue(dev, "dev", "api", time.Time{})
112
roTok := issue(ro, "ro", "api", time.Time{})
113
readAPI := issue(ada, "read", "read_api", time.Time{})
114
writeRepo := issue(dev, "wrepo", "write_repository", time.Time{})
115
readRepo := issue(dev, "rrepo", "read_repository", time.Time{})
116
expired := issue(ada, "old", "api", time.Now().Add(40*time.Millisecond))
117
time.Sleep(80 * time.Millisecond)
118
119
cfg := config.Config{
120
BaseURL: "http://127.0.0.1:9", StoragePath: storage,
121
Auth: config.Auth{Mode: "dev", DevUser: "ada", DevAuthID: 1},
122
Git: config.Git{Binary: "git", DefaultBranch: "master"},
123
CI: config.CI{Enabled: true},
124
}
125
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "ada", AuthID: 1}, Git: "git", HookBin: "/bin/true", StateDir: t.TempDir()}
126
ts := httptest.NewServer(srv.Handler())
127
t.Cleanup(ts.Close)
128
129
call := func(method, path, token, body string, hdr string) (int, string) {
130
t.Helper()
131
req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
132
if err != nil {
133
t.Fatal(err)
134
}
135
if body != "" {
136
req.Header.Set("Content-Type", "application/json")
137
}
138
switch hdr {
139
case "private":
140
req.Header.Set("PRIVATE-TOKEN", token)
141
case "basic":
142
req.SetBasicAuth("git", token)
143
default:
144
if token != "" {
145
req.Header.Set("Authorization", "Bearer "+token)
146
}
147
}
148
res, err := http.DefaultClient.Do(req)
149
if err != nil {
150
t.Fatal(err)
151
}
152
return res.StatusCode, read(t, res)
153
}
154
want := func(got int, body, label string, status int, contains string) {
155
t.Helper()
156
if got != status || (contains != "" && !strings.Contains(body, contains)) {
157
t.Fatalf("%s: status %d body %s", label, got, body)
158
}
159
}
160
161
code, body := call(http.MethodGet, "/api/v1/user", "", "", "")
162
want(code, body, "anoniem", 401, "message")
163
code, body = call(http.MethodGet, "/api/v1/openapi.json", "", "", "")
164
want(code, body, "openapi", 200, `"openapi":"3.0.3"`)
165
if !strings.Contains(body, "privateToken") || !strings.Contains(body, "/projects/{owner}/{repo}/merge_requests") {
166
t.Fatalf("openapi dekt niet: %s", body[:200])
167
}
168
code, body = call(http.MethodGet, "/api/v1/ci/spec", "", "", "")
169
want(code, body, "spec", 200, "blue-ci-cd.yml")
170
code, body = call(http.MethodGet, "/api/v1/ci/presets", "", "", "")
171
want(code, body, "presets", 200, "bluegit/")
172
code, body = call(http.MethodGet, "/api/v1/user", expired, "", "")
173
want(code, body, "verlopen", 401, "message")
174
code, body = call(http.MethodGet, "/api/v1/user", adaTok, "", "private")
175
want(code, body, "private-token", 200, `"username":"ada"`)
176
code, body = call(http.MethodGet, "/api/v1/user", adaTok, "", "basic")
177
want(code, body, "basic", 200, `"instance_admin":true`)
178
code, body = call(http.MethodPost, "/api/v1/user/tokens", readAPI, `{"name":"no"}`, "")
179
want(code, body, "read_api schrijft niet", 403, "message")
180
code, body = call(http.MethodGet, "/api/v1/user", readRepo, "", "")
181
want(code, body, "read_repository is geen api-lezen", 403, "message")
182
183
code, body = call(http.MethodPost, "/api/v1/projects", adaTok, `{"name":"Demo","description":"leeg","visibility":"private"}`, "")
184
want(code, body, "leeg project", 201, `"path":"ada/demo"`)
185
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits", adaTok, "", "")
186
want(code, body, "geen commits", 200, "[]")
187
code, body = call(http.MethodPost, "/api/v1/projects", adaTok, `{"name":"Readme","initialize_with_readme":true}`, "")
188
want(code, body, "readme", 201, `"path":"ada/readme"`)
189
code, body = call(http.MethodGet, "/api/v1/projects/ada/readme/repository/files/README.md", adaTok, "", "")
190
want(code, body, "bestand", 200, "# readme")
191
192
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo", roTok, "", "")
193
want(code, body, "prive zonder rol", 404, "message")
194
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/members", adaTok, `{"username":"ro","role":"readonly"}`, "")
195
want(code, body, "lid ro", 200, `"username":"ro"`)
196
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/members", adaTok, `{"username":"dev","role":"developer"}`, "")
197
want(code, body, "lid dev", 200, "developer")
198
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo", roTok, "", "")
199
want(code, body, "readonly ziet", 200, "ada/demo")
200
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/branches", roTok, `{"name":"nope"}`, "")
201
want(code, body, "readonly branch", 403, "message")
202
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/secrets", devTok, `{"name":"TOKEN","value":"x"}`, "")
203
want(code, body, "dev secret", 403, "message")
204
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/secrets", adaTok, `{"name":"TOKEN","value":"geheim"}`, "")
205
want(code, body, "secret", 200, "TOKEN")
206
code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo", devTok, `{"confirm":"demo"}`, "")
207
want(code, body, "dev verwijdert niet", 403, "message")
208
209
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/commits", adaTok, `{"branch":"master","commit_message":"eerste","actions":[{"action":"create","file_path":"a.txt","content":"hoi\n"}]}`, "")
210
want(code, body, "eerste commit", 201, `"id":`)
211
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/commits", writeRepo, `{"branch":"side","start_branch":"master","commit_message":"zijtak","actions":[{"action":"create","file_path":"b.txt","content":"meer\n"}]}`, "")
212
want(code, body, "write_repository commit", 201, `"id":`)
213
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/members", writeRepo, `{"username":"ro","role":"developer"}`, "")
214
want(code, body, "write_repository geen leden", 403, "message")
215
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/commits", readRepo, `{"branch":"master","commit_message":"nee","actions":[{"action":"update","file_path":"a.txt","content":"x"}]}`, "")
216
want(code, body, "read_repository schrijft niet", 403, "message")
217
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits", readAPI, "", "")
218
want(code, body, "read_api leest commits", 200, "eerste")
219
220
code, list := call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits", adaTok, "", "")
221
want(code, list, "lijst", 200, "eerste")
222
var rows []map[string]any
223
if err := json.Unmarshal([]byte(list), &rows); err != nil || len(rows) == 0 {
224
t.Fatalf("commits json %v %s", err, list)
225
}
226
sha, _ := rows[0]["id"].(string)
227
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits/"+sha+"/diff", adaTok, "", "")
228
want(code, body, "diff", 200, "a.txt")
229
230
req, err := http.NewRequest(http.MethodGet, ts.URL+"/ada/demo.git/info/refs?service=git-upload-pack", nil)
231
if err != nil {
232
t.Fatal(err)
233
}
234
req.SetBasicAuth("ada", readAPI)
235
res, err := http.DefaultClient.Do(req)
236
if err != nil {
237
t.Fatal(err)
238
}
239
_ = read(t, res)
240
if res.StatusCode != http.StatusForbidden {
241
t.Fatalf("read_api clone %d", res.StatusCode)
242
}
243
req, _ = http.NewRequest(http.MethodGet, ts.URL+"/ada/demo.git/info/refs?service=git-upload-pack", nil)
244
req.SetBasicAuth("dev", writeRepo)
245
res, err = http.DefaultClient.Do(req)
246
if err != nil {
247
t.Fatal(err)
248
}
249
_ = read(t, res)
250
if res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized {
251
t.Fatalf("write_repository leest git niet: %d", res.StatusCode)
252
}
253
254
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/branches", devTok, `{"name":"feature","from":"master"}`, "")
255
want(code, body, "branch", 201, "feature")
256
code, body = call(http.MethodPut, "/api/v1/projects/ada/demo/ci/file", devTok, `{"branch":"feature","base":"master","message":"ci","content":"stages: [test]\n"}`, "")
257
want(code, body, "ci-editor", 200, `"id"`)
258
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/ci/lint", roTok, `{"body":"stages: [test]\n","ref":"feature"}`, "")
259
want(code, body, "lint", 200, "status")
260
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests", adaTok, `{"title":"Werk","source_branch":"feature","target_branch":"master"}`, "")
261
want(code, body, "mr", 201, `"iid":`)
262
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests", readAPI, `{"title":"Nee","source_branch":"feature","target_branch":"master"}`, "")
263
want(code, body, "read_api mr", 403, "message")
264
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/notes", roTok, `{"body":"gezien"}`, "")
265
want(code, body, "note", 201, `"id"`)
266
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/close", devTok, `{}`, "")
267
want(code, body, "dev sluit andermans mr niet", 403, "message")
268
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/close", adaTok, `{}`, "")
269
want(code, body, "sluiten", 200, "closed")
270
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/reopen", adaTok, `{}`, "")
271
want(code, body, "heropenen", 200, "open")
272
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/pipelines", devTok, `{"ref":"feature"}`, "")
273
want(code, body, "pipeline", 201, `"id"`)
274
275
code, body = call(http.MethodPost, "/api/v1/groups", adaTok, `{"name":"Team","description":"samen"}`, "")
276
want(code, body, "groep", 201, `"path":"team"`)
277
code, body = call(http.MethodPut, "/api/v1/groups/team/approvals", adaTok, `{"maintainer_required":true,"required_count":1}`, "")
278
want(code, body, "approvals", 200, "maintainer_required")
279
code, body = call(http.MethodPost, "/api/v1/groups/team/webhooks", adaTok, `{"name":"ping","preset":"generic","url":"https://example.com/hook","events":["push"]}`, "")
280
want(code, body, "webhook", 201, `"id"`)
281
code, body = call(http.MethodPut, "/api/v1/admin/storage", devTok, `{"path":"/tmp"}`, "")
282
want(code, body, "dev geen admin", 403, "message")
283
code, body = call(http.MethodGet, "/api/v1/admin/storage", adaTok, "", "")
284
want(code, body, "storage", 200, storage)
285
286
status, raw := srv.CallAPI(ctx, ada, http.MethodGet, "/user", nil)
287
if status != 200 || !strings.Contains(string(raw), `"username":"ada"`) {
288
t.Fatalf("ssh-api %d %s", status, raw)
289
}
290
}
@@ -0,0 +1,290 @@1
package server2
3
import (4
"context"5
"encoding/json"6
"net/http"7
"net/http/httptest"8
"os/exec"9
"path/filepath"10
"strings"11
"testing"12
"time"13
14
"gitlab.com/Timfa/bluegit/internal/auth"15
"gitlab.com/Timfa/bluegit/internal/config"16
"gitlab.com/Timfa/bluegit/internal/store"17
)18
19
func TestAPICatalogCoversResources(t *testing.T) {20
var b strings.Builder21
b.WriteString("GET /api/v1/openapi.json\n")22
for _, rt := range apiCatalog {23
b.WriteString(rt.Method)24
b.WriteByte(' ')25
b.WriteString(rt.Path)26
b.WriteByte('\n')27
}28
blob := b.String()29
for _, want := range []string{30
"GET /api/v1/user\n",31
"PUT /api/v1/user\n",32
"GET /api/v1/user/export\n",33
"POST /api/v1/user/tokens\n",34
"DELETE /api/v1/user/tokens/{id}\n",35
"POST /api/v1/user/keys\n",36
"POST /api/v1/groups\n",37
"POST /api/v1/groups/{path}/transfer\n",38
"POST /api/v1/groups/{path}/members\n",39
"POST /api/v1/groups/{path}/secrets\n",40
"POST /api/v1/groups/{path}/webhooks\n",41
"PUT /api/v1/groups/{path}/approvals\n",42
"POST /api/v1/groups/{path}/logo\n",43
"POST /api/v1/projects\n",44
"DELETE /api/v1/projects/{owner}/{repo}\n",45
"POST /api/v1/projects/{owner}/{repo}/members\n",46
"POST /api/v1/projects/{owner}/{repo}/protected_branches\n",47
"POST /api/v1/projects/{owner}/{repo}/protected_tags\n",48
"POST /api/v1/projects/{owner}/{repo}/repository/branches\n",49
"DELETE /api/v1/projects/{owner}/{repo}/repository/branches/{branch...}\n",50
"POST /api/v1/projects/{owner}/{repo}/repository/tags\n",51
"GET /api/v1/projects/{owner}/{repo}/repository/files/{path...}\n",52
"POST /api/v1/projects/{owner}/{repo}/repository/commits\n",53
"GET /api/v1/projects/{owner}/{repo}/repository/commits/{sha}/diff\n",54
"POST /api/v1/projects/{owner}/{repo}/merge_requests\n",55
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/notes\n",56
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/reviews\n",57
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/suggestions\n",58
"POST /api/v1/projects/{owner}/{repo}/merge_requests/{number}/merge\n",59
"POST /api/v1/projects/{owner}/{repo}/pipelines\n",60
"POST /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/play\n",61
"POST /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/retry\n",62
"POST /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/cancel\n",63
"GET /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/log\n",64
"GET /api/v1/projects/{owner}/{repo}/pipelines/{id}/jobs/{job}/artifacts\n",65
"PUT /api/v1/projects/{owner}/{repo}/ci/file\n",66
"POST /api/v1/projects/{owner}/{repo}/ci/lint\n",67
"GET /api/v1/ci/spec\n",68
"GET /api/v1/ci/presets\n",69
"POST /api/v1/projects/{owner}/{repo}/releases\n",70
"POST /api/v1/repos/{owner}/{repo}/releases\n",71
"PUT /api/v1/admin/storage\n",72
} {73
if !strings.Contains(blob, want) {74
t.Errorf("catalog mist %s", strings.TrimSpace(want))75
}76
}77
}78
79
func TestAPIPermissionsAndResources(t *testing.T) {80
if _, err := exec.LookPath("git"); err != nil {81
t.Skip("git ontbreekt")82
}83
storage := t.TempDir()84
st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())85
if err != nil {86
t.Fatal(err)87
}88
t.Cleanup(func() { _ = st.Close() })89
ctx := context.Background()90
ada, err := st.UpsertUser(ctx, 1, "ada", "", false)91
if err != nil || !ada.InstanceAdmin {92
t.Fatalf("ada admin: %+v %v", ada, err)93
}94
dev, err := st.UpsertUser(ctx, 2, "dev", "", false)95
if err != nil {96
t.Fatal(err)97
}98
ro, err := st.UpsertUser(ctx, 3, "ro", "", false)99
if err != nil {100
t.Fatal(err)101
}102
issue := func(u store.User, name, scopes string, exp time.Time) string {103
t.Helper()104
plain, _, err := st.IssueToken(ctx, u.ID, store.TokenRequest{Name: name, Scopes: scopes, ExpiresAt: exp})105
if err != nil {106
t.Fatal(err)107
}108
return plain109
}110
adaTok := issue(ada, "ada", "api", time.Time{})111
devTok := issue(dev, "dev", "api", time.Time{})112
roTok := issue(ro, "ro", "api", time.Time{})113
readAPI := issue(ada, "read", "read_api", time.Time{})114
writeRepo := issue(dev, "wrepo", "write_repository", time.Time{})115
readRepo := issue(dev, "rrepo", "read_repository", time.Time{})116
expired := issue(ada, "old", "api", time.Now().Add(40*time.Millisecond))117
time.Sleep(80 * time.Millisecond)118
119
cfg := config.Config{120
BaseURL: "http://127.0.0.1:9", StoragePath: storage,121
Auth: config.Auth{Mode: "dev", DevUser: "ada", DevAuthID: 1},122
Git: config.Git{Binary: "git", DefaultBranch: "master"},123
CI: config.CI{Enabled: true},124
}125
srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "ada", AuthID: 1}, Git: "git", HookBin: "/bin/true", StateDir: t.TempDir()}126
ts := httptest.NewServer(srv.Handler())127
t.Cleanup(ts.Close)128
129
call := func(method, path, token, body string, hdr string) (int, string) {130
t.Helper()131
req, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))132
if err != nil {133
t.Fatal(err)134
}135
if body != "" {136
req.Header.Set("Content-Type", "application/json")137
}138
switch hdr {139
case "private":140
req.Header.Set("PRIVATE-TOKEN", token)141
case "basic":142
req.SetBasicAuth("git", token)143
default:144
if token != "" {145
req.Header.Set("Authorization", "Bearer "+token)146
}147
}148
res, err := http.DefaultClient.Do(req)149
if err != nil {150
t.Fatal(err)151
}152
return res.StatusCode, read(t, res)153
}154
want := func(got int, body, label string, status int, contains string) {155
t.Helper()156
if got != status || (contains != "" && !strings.Contains(body, contains)) {157
t.Fatalf("%s: status %d body %s", label, got, body)158
}159
}160
161
code, body := call(http.MethodGet, "/api/v1/user", "", "", "")162
want(code, body, "anoniem", 401, "message")163
code, body = call(http.MethodGet, "/api/v1/openapi.json", "", "", "")164
want(code, body, "openapi", 200, `"openapi":"3.0.3"`)165
if !strings.Contains(body, "privateToken") || !strings.Contains(body, "/projects/{owner}/{repo}/merge_requests") {166
t.Fatalf("openapi dekt niet: %s", body[:200])167
}168
code, body = call(http.MethodGet, "/api/v1/ci/spec", "", "", "")169
want(code, body, "spec", 200, "blue-ci-cd.yml")170
code, body = call(http.MethodGet, "/api/v1/ci/presets", "", "", "")171
want(code, body, "presets", 200, "bluegit/")172
code, body = call(http.MethodGet, "/api/v1/user", expired, "", "")173
want(code, body, "verlopen", 401, "message")174
code, body = call(http.MethodGet, "/api/v1/user", adaTok, "", "private")175
want(code, body, "private-token", 200, `"username":"ada"`)176
code, body = call(http.MethodGet, "/api/v1/user", adaTok, "", "basic")177
want(code, body, "basic", 200, `"instance_admin":true`)178
code, body = call(http.MethodPost, "/api/v1/user/tokens", readAPI, `{"name":"no"}`, "")179
want(code, body, "read_api schrijft niet", 403, "message")180
code, body = call(http.MethodGet, "/api/v1/user", readRepo, "", "")181
want(code, body, "read_repository is geen api-lezen", 403, "message")182
183
code, body = call(http.MethodPost, "/api/v1/projects", adaTok, `{"name":"Demo","description":"leeg","visibility":"private"}`, "")184
want(code, body, "leeg project", 201, `"path":"ada/demo"`)185
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits", adaTok, "", "")186
want(code, body, "geen commits", 200, "[]")187
code, body = call(http.MethodPost, "/api/v1/projects", adaTok, `{"name":"Readme","initialize_with_readme":true}`, "")188
want(code, body, "readme", 201, `"path":"ada/readme"`)189
code, body = call(http.MethodGet, "/api/v1/projects/ada/readme/repository/files/README.md", adaTok, "", "")190
want(code, body, "bestand", 200, "# readme")191
192
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo", roTok, "", "")193
want(code, body, "prive zonder rol", 404, "message")194
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/members", adaTok, `{"username":"ro","role":"readonly"}`, "")195
want(code, body, "lid ro", 200, `"username":"ro"`)196
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/members", adaTok, `{"username":"dev","role":"developer"}`, "")197
want(code, body, "lid dev", 200, "developer")198
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo", roTok, "", "")199
want(code, body, "readonly ziet", 200, "ada/demo")200
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/branches", roTok, `{"name":"nope"}`, "")201
want(code, body, "readonly branch", 403, "message")202
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/secrets", devTok, `{"name":"TOKEN","value":"x"}`, "")203
want(code, body, "dev secret", 403, "message")204
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/secrets", adaTok, `{"name":"TOKEN","value":"geheim"}`, "")205
want(code, body, "secret", 200, "TOKEN")206
code, body = call(http.MethodDelete, "/api/v1/projects/ada/demo", devTok, `{"confirm":"demo"}`, "")207
want(code, body, "dev verwijdert niet", 403, "message")208
209
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/commits", adaTok, `{"branch":"master","commit_message":"eerste","actions":[{"action":"create","file_path":"a.txt","content":"hoi\n"}]}`, "")210
want(code, body, "eerste commit", 201, `"id":`)211
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/commits", writeRepo, `{"branch":"side","start_branch":"master","commit_message":"zijtak","actions":[{"action":"create","file_path":"b.txt","content":"meer\n"}]}`, "")212
want(code, body, "write_repository commit", 201, `"id":`)213
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/members", writeRepo, `{"username":"ro","role":"developer"}`, "")214
want(code, body, "write_repository geen leden", 403, "message")215
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/commits", readRepo, `{"branch":"master","commit_message":"nee","actions":[{"action":"update","file_path":"a.txt","content":"x"}]}`, "")216
want(code, body, "read_repository schrijft niet", 403, "message")217
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits", readAPI, "", "")218
want(code, body, "read_api leest commits", 200, "eerste")219
220
code, list := call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits", adaTok, "", "")221
want(code, list, "lijst", 200, "eerste")222
var rows []map[string]any223
if err := json.Unmarshal([]byte(list), &rows); err != nil || len(rows) == 0 {224
t.Fatalf("commits json %v %s", err, list)225
}226
sha, _ := rows[0]["id"].(string)227
code, body = call(http.MethodGet, "/api/v1/projects/ada/demo/repository/commits/"+sha+"/diff", adaTok, "", "")228
want(code, body, "diff", 200, "a.txt")229
230
req, err := http.NewRequest(http.MethodGet, ts.URL+"/ada/demo.git/info/refs?service=git-upload-pack", nil)231
if err != nil {232
t.Fatal(err)233
}234
req.SetBasicAuth("ada", readAPI)235
res, err := http.DefaultClient.Do(req)236
if err != nil {237
t.Fatal(err)238
}239
_ = read(t, res)240
if res.StatusCode != http.StatusForbidden {241
t.Fatalf("read_api clone %d", res.StatusCode)242
}243
req, _ = http.NewRequest(http.MethodGet, ts.URL+"/ada/demo.git/info/refs?service=git-upload-pack", nil)244
req.SetBasicAuth("dev", writeRepo)245
res, err = http.DefaultClient.Do(req)246
if err != nil {247
t.Fatal(err)248
}249
_ = read(t, res)250
if res.StatusCode == http.StatusForbidden || res.StatusCode == http.StatusUnauthorized {251
t.Fatalf("write_repository leest git niet: %d", res.StatusCode)252
}253
254
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/repository/branches", devTok, `{"name":"feature","from":"master"}`, "")255
want(code, body, "branch", 201, "feature")256
code, body = call(http.MethodPut, "/api/v1/projects/ada/demo/ci/file", devTok, `{"branch":"feature","base":"master","message":"ci","content":"stages: [test]\n"}`, "")257
want(code, body, "ci-editor", 200, `"id"`)258
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/ci/lint", roTok, `{"body":"stages: [test]\n","ref":"feature"}`, "")259
want(code, body, "lint", 200, "status")260
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests", adaTok, `{"title":"Werk","source_branch":"feature","target_branch":"master"}`, "")261
want(code, body, "mr", 201, `"iid":`)262
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests", readAPI, `{"title":"Nee","source_branch":"feature","target_branch":"master"}`, "")263
want(code, body, "read_api mr", 403, "message")264
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/notes", roTok, `{"body":"gezien"}`, "")265
want(code, body, "note", 201, `"id"`)266
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/close", devTok, `{}`, "")267
want(code, body, "dev sluit andermans mr niet", 403, "message")268
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/close", adaTok, `{}`, "")269
want(code, body, "sluiten", 200, "closed")270
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/merge_requests/1/reopen", adaTok, `{}`, "")271
want(code, body, "heropenen", 200, "open")272
code, body = call(http.MethodPost, "/api/v1/projects/ada/demo/pipelines", devTok, `{"ref":"feature"}`, "")273
want(code, body, "pipeline", 201, `"id"`)274
275
code, body = call(http.MethodPost, "/api/v1/groups", adaTok, `{"name":"Team","description":"samen"}`, "")276
want(code, body, "groep", 201, `"path":"team"`)277
code, body = call(http.MethodPut, "/api/v1/groups/team/approvals", adaTok, `{"maintainer_required":true,"required_count":1}`, "")278
want(code, body, "approvals", 200, "maintainer_required")279
code, body = call(http.MethodPost, "/api/v1/groups/team/webhooks", adaTok, `{"name":"ping","preset":"generic","url":"https://example.com/hook","events":["push"]}`, "")280
want(code, body, "webhook", 201, `"id"`)281
code, body = call(http.MethodPut, "/api/v1/admin/storage", devTok, `{"path":"/tmp"}`, "")282
want(code, body, "dev geen admin", 403, "message")283
code, body = call(http.MethodGet, "/api/v1/admin/storage", adaTok, "", "")284
want(code, body, "storage", 200, storage)285
286
status, raw := srv.CallAPI(ctx, ada, http.MethodGet, "/user", nil)287
if status != 200 || !strings.Contains(string(raw), `"username":"ada"`) {288
t.Fatalf("ssh-api %d %s", status, raw)289
}290
}@@ -5,9 +5,6 @@ import (
5
5
"net/http"
6
6
"strings"
7
7
"time"
8
9
"gitlab.com/Timfa/bluegit/internal/access"
10
"golang.org/x/crypto/ssh"
11
8
)
12
9
13
10
func (s *Server) login(w http.ResponseWriter, r *http.Request) {
@@ -164,7 +161,7 @@ func (s *Server) createToken(w http.ResponseWriter, r *http.Request) {
164
161
if !ok || !s.csrfOK(w, r) {
165
162
return
166
163
}
167
plain, err := s.Store.CreateToken(r.Context(), u.ID, r.FormValue("name"))
164
plain, _, err := s.opIssueToken(r.Context(), u, r.FormValue("name"), nil, time.Time{})
168
165
if err != nil {
169
166
s.redirect(w, r, "/settings", "", s.trErr(r, err))
170
167
return
@@ -181,7 +178,7 @@ func (s *Server) deleteToken(w http.ResponseWriter, r *http.Request) {
181
178
}
182
179
var id int64
183
180
_, _ = parseID(r.FormValue("id"), &id)
184
if err := s.Store.DeleteToken(r.Context(), u.ID, id); err != nil {
181
if err := s.opRevokeToken(r.Context(), u, id); err != nil {
185
182
s.redirect(w, r, "/settings", "", s.tr(r, "err.tokenMissing"))
186
183
return
187
184
}
@@ -193,16 +190,8 @@ func (s *Server) addSSH(w http.ResponseWriter, r *http.Request) {
193
190
if !ok || !s.csrfOK(w, r) {
194
191
return
195
192
}
196
line := strings.TrimSpace(r.FormValue("key"))
197
pub, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))
198
if err != nil {
199
s.redirect(w, r, "/settings", "", s.tr(r, "err.sshBad"))
200
return
201
}
202
stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))
203
fp := ssh.FingerprintSHA256(pub)
204
if err := s.Store.AddSSHKey(r.Context(), u.ID, r.FormValue("name"), stored, fp); err != nil {
205
s.redirect(w, r, "/settings", "", s.trErr(r, err))
193
if err := s.opAddSSH(r.Context(), u, r.FormValue("name"), r.FormValue("key")); err != nil {
194
s.redirect(w, r, "/settings", "", s.commitProblem(r, err))
206
195
return
207
196
}
208
197
s.redirect(w, r, "/settings", s.tr(r, "flash.sshAdded"), "")
@@ -215,7 +204,7 @@ func (s *Server) deleteSSH(w http.ResponseWriter, r *http.Request) {
215
204
}
216
205
var id int64
217
206
_, _ = parseID(r.FormValue("id"), &id)
218
if err := s.Store.DeleteSSHKey(r.Context(), u.ID, id); err != nil {
207
if err := s.opRemoveSSH(r.Context(), u, id); err != nil {
219
208
s.redirect(w, r, "/settings", "", s.tr(r, "err.sshMissing"))
220
209
return
221
210
}
@@ -227,58 +216,7 @@ func (s *Server) export(w http.ResponseWriter, r *http.Request) {
227
216
if !ok {
228
217
return
229
218
}
230
type secretRow struct {
231
Scope string `json:"scope"`
232
Name string `json:"name"`
233
Value string `json:"value"`
234
}
235
var secrets []secretRow
236
ids, _ := s.Store.ListRepoIDs(r.Context(), u.ID)
237
for _, id := range ids {
238
role, err := s.Store.EffectiveRole(r.Context(), u.ID, id)
239
if err != nil || !role.CanManageSecrets() {
240
continue
241
}
242
repo, err := s.Store.RepoByID(r.Context(), id)
243
if err != nil {
244
continue
245
}
246
vals, err := s.Store.SecretValues(r.Context(), "repo", id, true)
247
if err != nil {
248
continue
249
}
250
for name, value := range vals {
251
secrets = append(secrets, secretRow{Scope: "repo:" + repo.FullPath(), Name: name, Value: value})
252
}
253
}
254
groups, _ := s.Store.ListGroups(r.Context(), u.ID)
255
for _, g := range groups {
256
role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
257
if err != nil || !role.AtLeast(access.RoleMaintainer) {
258
continue
259
}
260
vals, err := s.Store.SecretValues(r.Context(), "group", g.ID, true)
261
if err != nil {
262
continue
263
}
264
for name, value := range vals {
265
secrets = append(secrets, secretRow{Scope: "group:" + g.Path, Name: name, Value: value})
266
}
267
}
268
tokens, _ := s.Store.ListTokens(r.Context(), u.ID)
269
keys, _ := s.Store.ListSSHKeys(r.Context(), u.ID)
270
payload := map[string]any{
271
"exported_at": time.Now().UTC().Format(time.RFC3339),
272
"account": map[string]any{
273
"id": u.AuthID,
274
"username": u.Username,
275
"avatar_url": u.AvatarURL,
276
"instance_admin": u.InstanceAdmin,
277
},
278
"tokens": tokens,
279
"ssh_keys": keys,
280
"secrets": secrets,
281
}
219
payload := s.opExport(r.Context(), u)
282
220
w.Header().Set("Content-Type", "application/json; charset=utf-8")
283
221
w.Header().Set("Content-Disposition", `attachment; filename="bluegit-export.json"`)
284
222
enc := json.NewEncoder(w)
@@ -5,9 +5,6 @@ import (5
"net/http"5
"net/http"6
"strings"6
"strings"7
"time"7
"time"8
9
"gitlab.com/Timfa/bluegit/internal/access"10
"golang.org/x/crypto/ssh"11
)8
)12
9
13
func (s *Server) login(w http.ResponseWriter, r *http.Request) {10
func (s *Server) login(w http.ResponseWriter, r *http.Request) {@@ -164,7 +161,7 @@ func (s *Server) createToken(w http.ResponseWriter, r *http.Request) {164
if !ok || !s.csrfOK(w, r) {161
if !ok || !s.csrfOK(w, r) {165
return162
return166
}163
}167
plain, err := s.Store.CreateToken(r.Context(), u.ID, r.FormValue("name"))164
plain, _, err := s.opIssueToken(r.Context(), u, r.FormValue("name"), nil, time.Time{})168
if err != nil {165
if err != nil {169
s.redirect(w, r, "/settings", "", s.trErr(r, err))166
s.redirect(w, r, "/settings", "", s.trErr(r, err))170
return167
return@@ -181,7 +178,7 @@ func (s *Server) deleteToken(w http.ResponseWriter, r *http.Request) {181
}178
}182
var id int64179
var id int64183
_, _ = parseID(r.FormValue("id"), &id)180
_, _ = parseID(r.FormValue("id"), &id)184
if err := s.Store.DeleteToken(r.Context(), u.ID, id); err != nil {181
if err := s.opRevokeToken(r.Context(), u, id); err != nil {185
s.redirect(w, r, "/settings", "", s.tr(r, "err.tokenMissing"))182
s.redirect(w, r, "/settings", "", s.tr(r, "err.tokenMissing"))186
return183
return187
}184
}@@ -193,16 +190,8 @@ func (s *Server) addSSH(w http.ResponseWriter, r *http.Request) {193
if !ok || !s.csrfOK(w, r) {190
if !ok || !s.csrfOK(w, r) {194
return191
return195
}192
}196
line := strings.TrimSpace(r.FormValue("key"))193
if err := s.opAddSSH(r.Context(), u, r.FormValue("name"), r.FormValue("key")); err != nil {197
pub, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))194
s.redirect(w, r, "/settings", "", s.commitProblem(r, err))198
if err != nil {199
s.redirect(w, r, "/settings", "", s.tr(r, "err.sshBad"))200
return201
}202
stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))203
fp := ssh.FingerprintSHA256(pub)204
if err := s.Store.AddSSHKey(r.Context(), u.ID, r.FormValue("name"), stored, fp); err != nil {205
s.redirect(w, r, "/settings", "", s.trErr(r, err))206
return195
return207
}196
}208
s.redirect(w, r, "/settings", s.tr(r, "flash.sshAdded"), "")197
s.redirect(w, r, "/settings", s.tr(r, "flash.sshAdded"), "")@@ -215,7 +204,7 @@ func (s *Server) deleteSSH(w http.ResponseWriter, r *http.Request) {215
}204
}216
var id int64205
var id int64217
_, _ = parseID(r.FormValue("id"), &id)206
_, _ = parseID(r.FormValue("id"), &id)218
if err := s.Store.DeleteSSHKey(r.Context(), u.ID, id); err != nil {207
if err := s.opRemoveSSH(r.Context(), u, id); err != nil {219
s.redirect(w, r, "/settings", "", s.tr(r, "err.sshMissing"))208
s.redirect(w, r, "/settings", "", s.tr(r, "err.sshMissing"))220
return209
return221
}210
}@@ -227,58 +216,7 @@ func (s *Server) export(w http.ResponseWriter, r *http.Request) {227
if !ok {216
if !ok {228
return217
return229
}218
}230
type secretRow struct {219
payload := s.opExport(r.Context(), u)231
Scope string `json:"scope"`232
Name string `json:"name"`233
Value string `json:"value"`234
}235
var secrets []secretRow236
ids, _ := s.Store.ListRepoIDs(r.Context(), u.ID)237
for _, id := range ids {238
role, err := s.Store.EffectiveRole(r.Context(), u.ID, id)239
if err != nil || !role.CanManageSecrets() {240
continue241
}242
repo, err := s.Store.RepoByID(r.Context(), id)243
if err != nil {244
continue245
}246
vals, err := s.Store.SecretValues(r.Context(), "repo", id, true)247
if err != nil {248
continue249
}250
for name, value := range vals {251
secrets = append(secrets, secretRow{Scope: "repo:" + repo.FullPath(), Name: name, Value: value})252
}253
}254
groups, _ := s.Store.ListGroups(r.Context(), u.ID)255
for _, g := range groups {256
role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)257
if err != nil || !role.AtLeast(access.RoleMaintainer) {258
continue259
}260
vals, err := s.Store.SecretValues(r.Context(), "group", g.ID, true)261
if err != nil {262
continue263
}264
for name, value := range vals {265
secrets = append(secrets, secretRow{Scope: "group:" + g.Path, Name: name, Value: value})266
}267
}268
tokens, _ := s.Store.ListTokens(r.Context(), u.ID)269
keys, _ := s.Store.ListSSHKeys(r.Context(), u.ID)270
payload := map[string]any{271
"exported_at": time.Now().UTC().Format(time.RFC3339),272
"account": map[string]any{273
"id": u.AuthID,274
"username": u.Username,275
"avatar_url": u.AvatarURL,276
"instance_admin": u.InstanceAdmin,277
},278
"tokens": tokens,279
"ssh_keys": keys,280
"secrets": secrets,281
}282
w.Header().Set("Content-Type", "application/json; charset=utf-8")220
w.Header().Set("Content-Type", "application/json; charset=utf-8")283
w.Header().Set("Content-Disposition", `attachment; filename="bluegit-export.json"`)221
w.Header().Set("Content-Disposition", `attachment; filename="bluegit-export.json"`)284
enc := json.NewEncoder(w)222
enc := json.NewEncoder(w)@@ -3,11 +3,9 @@ package server
3
3
import (
4
4
"net/http"
5
5
"sort"
6
"strings"
7
6
8
7
"gitlab.com/Timfa/bluegit/internal/access"
9
8
"gitlab.com/Timfa/bluegit/internal/gitrepo"
10
"gitlab.com/Timfa/bluegit/internal/names"
11
9
"gitlab.com/Timfa/bluegit/internal/store"
12
10
)
13
11
@@ -59,104 +57,36 @@ func (s *Server) branches(w http.ResponseWriter, r *http.Request) {
59
57
}
60
58
61
59
func (s *Server) createBranch(w http.ResponseWriter, r *http.Request) {
62
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
60
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
63
61
if !ok || !s.csrfOK(w, r) {
64
62
return
65
63
}
66
64
back := repoURL(repo) + "/-/branches"
67
if !role.CanWriteCode() {
68
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
69
return
70
}
71
name := strings.TrimSpace(r.FormValue("name"))
72
if err := names.ValidBranch(name); err != nil {
73
s.redirect(w, r, back, "", s.trErr(r, err))
74
return
75
}
76
from := safeRev(r.FormValue("from"), repo.DefaultBranch)
77
if from == "" {
78
s.redirect(w, r, back, "", s.tr(r, "err.branches"))
79
return
80
}
81
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
82
if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != "" {
83
s.redirect(w, r, back, "", s.tr(r, "err.branchName", name))
84
return
85
}
86
if err := s.postReceive(r.Context(), repo, u, dir, func() error {
87
return gitrepo.CreateBranch(r.Context(), s.Git, dir, name, from)
88
}); err != nil {
89
s.redirect(w, r, back, "", s.commitProblem(r, err))
65
if !s.uiOK(w, r, back, s.opCreateBranch(r.Context(), u, repo, r.FormValue("name"), r.FormValue("from"))) {
90
66
return
91
67
}
92
68
s.redirect(w, r, back, s.tr(r, "flash.branchCreated"), "")
93
69
}
94
70
95
71
func (s *Server) deleteBranch(w http.ResponseWriter, r *http.Request) {
96
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
72
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
97
73
if !ok || !s.csrfOK(w, r) {
98
74
return
99
75
}
100
76
back := repoURL(repo) + "/-/branches"
101
if !role.CanWriteCode() {
102
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
103
return
104
}
105
name := strings.TrimSpace(r.FormValue("name"))
106
if r.FormValue("confirm") != name || name == "" {
107
s.redirect(w, r, back, "", s.tr(r, "err.branchConfirm"))
108
return
109
}
110
if locked, text := s.branchLocked(r, repo, name); locked {
111
s.redirect(w, r, back, "", text)
112
return
113
}
114
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
115
if err := s.postReceive(r.Context(), repo, u, dir, func() error {
116
return gitrepo.DeleteBranch(r.Context(), s.Git, dir, name)
117
}); err != nil {
118
s.redirect(w, r, back, "", s.commitProblem(r, err))
77
if !s.uiOK(w, r, back, s.opDeleteBranch(r.Context(), u, repo, r.FormValue("name"), r.FormValue("confirm"))) {
119
78
return
120
79
}
121
80
s.redirect(w, r, back, s.tr(r, "flash.branchDeleted"), "")
122
81
}
123
82
124
83
func (s *Server) renameBranch(w http.ResponseWriter, r *http.Request) {
125
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
84
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
126
85
if !ok || !s.csrfOK(w, r) {
127
86
return
128
87
}
129
88
back := repoURL(repo) + "/-/branches"
130
if !role.CanWriteCode() {
131
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
132
return
133
}
134
name := strings.TrimSpace(r.FormValue("name"))
135
newName := strings.TrimSpace(r.FormValue("new_name"))
136
if r.FormValue("confirm") != name || name == "" {
137
s.redirect(w, r, back, "", s.tr(r, "err.branchConfirm"))
138
return
139
}
140
if err := names.ValidBranch(newName); err != nil {
141
s.redirect(w, r, back, "", s.trErr(r, err))
142
return
143
}
144
if locked, text := s.branchLocked(r, repo, name); locked {
145
s.redirect(w, r, back, "", text)
146
return
147
}
148
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
149
if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+newName) != "" {
150
s.redirect(w, r, back, "", s.tr(r, "err.branchName", newName))
151
return
152
}
153
if err := s.postReceive(r.Context(), repo, u, dir, func() error {
154
if err := gitrepo.RenameBranch(r.Context(), s.Git, dir, name, newName); err != nil {
155
return err
156
}
157
return s.Store.RenameOpenMRBranches(r.Context(), repo.ID, name, newName)
158
}); err != nil {
159
s.redirect(w, r, back, "", s.commitProblem(r, err))
89
if !s.uiOK(w, r, back, s.opRenameBranch(r.Context(), u, repo, r.FormValue("name"), r.FormValue("new_name"), r.FormValue("confirm"))) {
160
90
return
161
91
}
162
92
s.redirect(w, r, back, s.tr(r, "flash.branchRenamed"), "")
@@ -3,11 +3,9 @@ package server3
import (3
import (4
"net/http"4
"net/http"5
"sort"5
"sort"6
"strings"7
6
8
"gitlab.com/Timfa/bluegit/internal/access"7
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/gitrepo"8
"gitlab.com/Timfa/bluegit/internal/gitrepo"10
"gitlab.com/Timfa/bluegit/internal/names"11
"gitlab.com/Timfa/bluegit/internal/store"9
"gitlab.com/Timfa/bluegit/internal/store"12
)10
)13
11
@@ -59,104 +57,36 @@ func (s *Server) branches(w http.ResponseWriter, r *http.Request) {59
}57
}60
58
61
func (s *Server) createBranch(w http.ResponseWriter, r *http.Request) {59
func (s *Server) createBranch(w http.ResponseWriter, r *http.Request) {62
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)60
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)63
if !ok || !s.csrfOK(w, r) {61
if !ok || !s.csrfOK(w, r) {64
return62
return65
}63
}66
back := repoURL(repo) + "/-/branches"64
back := repoURL(repo) + "/-/branches"67
if !role.CanWriteCode() {65
if !s.uiOK(w, r, back, s.opCreateBranch(r.Context(), u, repo, r.FormValue("name"), r.FormValue("from"))) {68
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)69
return70
}71
name := strings.TrimSpace(r.FormValue("name"))72
if err := names.ValidBranch(name); err != nil {73
s.redirect(w, r, back, "", s.trErr(r, err))74
return75
}76
from := safeRev(r.FormValue("from"), repo.DefaultBranch)77
if from == "" {78
s.redirect(w, r, back, "", s.tr(r, "err.branches"))79
return80
}81
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)82
if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != "" {83
s.redirect(w, r, back, "", s.tr(r, "err.branchName", name))84
return85
}86
if err := s.postReceive(r.Context(), repo, u, dir, func() error {87
return gitrepo.CreateBranch(r.Context(), s.Git, dir, name, from)88
}); err != nil {89
s.redirect(w, r, back, "", s.commitProblem(r, err))90
return66
return91
}67
}92
s.redirect(w, r, back, s.tr(r, "flash.branchCreated"), "")68
s.redirect(w, r, back, s.tr(r, "flash.branchCreated"), "")93
}69
}94
70
95
func (s *Server) deleteBranch(w http.ResponseWriter, r *http.Request) {71
func (s *Server) deleteBranch(w http.ResponseWriter, r *http.Request) {96
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)72
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)97
if !ok || !s.csrfOK(w, r) {73
if !ok || !s.csrfOK(w, r) {98
return74
return99
}75
}100
back := repoURL(repo) + "/-/branches"76
back := repoURL(repo) + "/-/branches"101
if !role.CanWriteCode() {77
if !s.uiOK(w, r, back, s.opDeleteBranch(r.Context(), u, repo, r.FormValue("name"), r.FormValue("confirm"))) {102
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)103
return104
}105
name := strings.TrimSpace(r.FormValue("name"))106
if r.FormValue("confirm") != name || name == "" {107
s.redirect(w, r, back, "", s.tr(r, "err.branchConfirm"))108
return109
}110
if locked, text := s.branchLocked(r, repo, name); locked {111
s.redirect(w, r, back, "", text)112
return113
}114
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)115
if err := s.postReceive(r.Context(), repo, u, dir, func() error {116
return gitrepo.DeleteBranch(r.Context(), s.Git, dir, name)117
}); err != nil {118
s.redirect(w, r, back, "", s.commitProblem(r, err))119
return78
return120
}79
}121
s.redirect(w, r, back, s.tr(r, "flash.branchDeleted"), "")80
s.redirect(w, r, back, s.tr(r, "flash.branchDeleted"), "")122
}81
}123
82
124
func (s *Server) renameBranch(w http.ResponseWriter, r *http.Request) {83
func (s *Server) renameBranch(w http.ResponseWriter, r *http.Request) {125
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)84
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)126
if !ok || !s.csrfOK(w, r) {85
if !ok || !s.csrfOK(w, r) {127
return86
return128
}87
}129
back := repoURL(repo) + "/-/branches"88
back := repoURL(repo) + "/-/branches"130
if !role.CanWriteCode() {89
if !s.uiOK(w, r, back, s.opRenameBranch(r.Context(), u, repo, r.FormValue("name"), r.FormValue("new_name"), r.FormValue("confirm"))) {131
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)132
return133
}134
name := strings.TrimSpace(r.FormValue("name"))135
newName := strings.TrimSpace(r.FormValue("new_name"))136
if r.FormValue("confirm") != name || name == "" {137
s.redirect(w, r, back, "", s.tr(r, "err.branchConfirm"))138
return139
}140
if err := names.ValidBranch(newName); err != nil {141
s.redirect(w, r, back, "", s.trErr(r, err))142
return143
}144
if locked, text := s.branchLocked(r, repo, name); locked {145
s.redirect(w, r, back, "", text)146
return147
}148
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)149
if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+newName) != "" {150
s.redirect(w, r, back, "", s.tr(r, "err.branchName", newName))151
return152
}153
if err := s.postReceive(r.Context(), repo, u, dir, func() error {154
if err := gitrepo.RenameBranch(r.Context(), s.Git, dir, name, newName); err != nil {155
return err156
}157
return s.Store.RenameOpenMRBranches(r.Context(), repo.ID, name, newName)158
}); err != nil {159
s.redirect(w, r, back, "", s.commitProblem(r, err))160
return90
return161
}91
}162
s.redirect(w, r, back, s.tr(r, "flash.branchRenamed"), "")92
s.redirect(w, r, back, s.tr(r, "flash.branchRenamed"), "")@@ -1,6 +1,7 @@
1
1
package server
2
2
3
3
import (
4
"context"
4
5
"encoding/json"
5
6
"errors"
6
7
"html/template"
@@ -104,94 +105,33 @@ func (s *Server) lintCI(w http.ResponseWriter, r *http.Request) {
104
105
if !ok || !s.csrfOK(w, r) {
105
106
return
106
107
}
107
body := r.FormValue("body")
108
if len(body) > ciMaxBytes {
109
http.Error(w, s.tr(r, "edit.fail"), http.StatusBadRequest)
108
out, err := s.opLintCI(r, repo, r.FormValue("body"), r.FormValue("ref"))
109
if err != nil {
110
http.Error(w, s.trErr(r, err), statusOf(err))
110
111
return
111
112
}
112
ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
113
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
114
model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))
115
lines := make([]string, len(model.Rows))
116
var bad []int
117
for i, row := range model.Rows {
118
lines[i] = string(row.HTML)
119
if row.Bad {
120
bad = append(bad, row.N)
121
}
122
}
123
113
w.Header().Set("Content-Type", "application/json")
124
_ = json.NewEncoder(w).Encode(map[string]any{
125
"status": model.Status,
126
"statusClass": model.Class,
127
"errors": model.Errors,
128
"warnings": model.Warnings,
129
"issues": model.Issues,
130
"lines": lines,
131
"bad": bad,
132
})
114
_ = json.NewEncoder(w).Encode(out)
133
115
}
134
116
135
117
func (s *Server) saveCIEditor(w http.ResponseWriter, r *http.Request) {
136
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
118
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
137
119
if !ok || !s.csrfOK(w, r) {
138
120
return
139
121
}
140
base := safeRev(r.FormValue("base"), repo.DefaultBranch)
141
122
branch := strings.TrimSpace(r.FormValue("branch"))
142
if !validBranchName(branch) {
143
s.redirect(w, r, repoURL(repo)+"/-/ci/editor?ref="+url.QueryEscape(base), "", s.tr(r, "edit.badBranch"))
144
return
145
}
123
base := r.FormValue("base")
146
124
back := repoURL(repo) + "/-/ci/editor?ref=" + url.QueryEscape(branch)
147
message := strings.TrimSpace(r.FormValue("message"))
148
if message == "" {
149
s.redirect(w, r, back, "", s.tr(r, "edit.needMessage"))
150
return
151
}
152
body := r.FormValue("body")
153
if len(body) > ciMaxBytes {
154
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))
155
return
156
}
157
125
openMR := r.FormValue("open_mr") == "1"
158
patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
159
if openMR && (branch == base || access.BranchProtected(patterns, branch)) {
160
s.redirect(w, r, back, "", s.tr(r, "edit.badBranch"))
161
return
162
}
163
if access.BranchProtected(patterns, branch) && !role.CanPushBranch(true) {
164
s.redirect(w, r, back, "", s.tr(r, "edit.protected"))
165
return
166
}
167
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
168
work, err := s.scratchDir("ci-edit")
169
if err != nil {
170
s.redirect(w, r, back, "", s.commitProblem(r, err))
171
return
172
}
173
defer os.RemoveAll(work)
174
if err := s.ensureBranch(r, dir, branch, base, work); err != nil {
175
s.redirect(w, r, back, "", s.commitProblem(r, err))
176
return
177
}
178
email := u.Username + "@users.git.timfalken.com"
179
err = s.postReceive(r.Context(), repo, u, dir, func() error {
180
return gitrepo.CommitOnBranch(r.Context(), s.Git, dir, work, branch, u.Username, email, message, "", map[string]string{ciFile: body}, role, patterns)
181
})
126
_, number, err := s.opSaveCI(r.Context(), u, repo, base, branch, r.FormValue("message"), r.FormValue("body"), openMR)
182
127
if err != nil {
128
if strings.TrimSpace(branch) == "" || !validBranchName(branch) {
129
back = repoURL(repo) + "/-/ci/editor?ref=" + url.QueryEscape(safeRev(base, repo.DefaultBranch))
130
}
183
131
s.redirect(w, r, back, "", s.commitProblem(r, err))
184
132
return
185
133
}
186
if openMR {
187
number, mrErr := s.openCIMergeRequest(r, repo, u, dir, branch, base, message)
188
if mrErr != nil {
189
if s.Log != nil {
190
s.Log.Error("ci-editor-mr", "err", mrErr)
191
}
192
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))
193
return
194
}
134
if openMR && number > 0 {
195
135
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(number, 10), s.tr(r, "flash.mrOpened"), "")
196
136
return
197
137
}
@@ -312,17 +252,17 @@ func (s *Server) includeFrom(r *http.Request, dir, ref string) func(string) ([]b
312
252
}
313
253
}
314
254
315
func (s *Server) ensureBranch(r *http.Request, dir, branch, base, work string) error {
255
func (s *Server) ensureBranch(ctx context.Context, dir, branch, base, work string) error {
316
256
home := filepath.Join(work, "home")
317
257
if err := os.MkdirAll(home, 0o700); err != nil {
318
258
return gitrepo.Cause("edit.failWrite", err.Error())
319
259
}
320
260
env := gitrepo.CommandEnv("bluegit", "bluegit@users.git.timfalken.com", home, home)
321
if s.gitEnv(r, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch) != "" {
261
if s.gitEnv(ctx, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch) != "" {
322
262
return nil
323
263
}
324
if s.gitEnv(r, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+base) != "" {
325
cmd := exec.CommandContext(r.Context(), s.Git, "-C", dir, "branch", branch, base)
264
if s.gitEnv(ctx, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+base) != "" {
265
cmd := exec.CommandContext(ctx, s.Git, "-C", dir, "branch", branch, base)
326
266
cmd.Env = env
327
267
if out, err := cmd.CombinedOutput(); err != nil {
328
268
return gitrepo.Cause("edit.failBranch", strings.TrimSpace(string(out)))
@@ -331,18 +271,18 @@ func (s *Server) ensureBranch(r *http.Request, dir, branch, base, work string) e
331
271
}
332
272
// Nog geen enkele commit. De gekozen branch wordt de eerste, zonder parent.
333
273
// Een beheerder, ook de eigenaar, mag dat ook op een beschermde branch.
334
if s.gitEnv(r, dir, env, "rev-parse", "--verify", "--quiet", "HEAD") == "" {
274
if s.gitEnv(ctx, dir, env, "rev-parse", "--verify", "--quiet", "HEAD") == "" {
335
275
return nil
336
276
}
337
277
return i18n.E("edit.failBranch")
338
278
}
339
279
340
func (s *Server) gitEnv(r *http.Request, dir string, env []string, args ...string) string {
280
func (s *Server) gitEnv(ctx context.Context, dir string, env []string, args ...string) string {
341
281
bin := s.Git
342
282
if bin == "" {
343
283
bin = "git"
344
284
}
345
cmd := exec.CommandContext(r.Context(), bin, append([]string{"-C", dir}, args...)...)
285
cmd := exec.CommandContext(ctx, bin, append([]string{"-C", dir}, args...)...)
346
286
cmd.Env = env
347
287
out, err := cmd.Output()
348
288
if err != nil {
@@ -1,6 +1,7 @@1
package server1
package server2
2
3
import (3
import (4
"context"4
"encoding/json"5
"encoding/json"5
"errors"6
"errors"6
"html/template"7
"html/template"@@ -104,94 +105,33 @@ func (s *Server) lintCI(w http.ResponseWriter, r *http.Request) {104
if !ok || !s.csrfOK(w, r) {105
if !ok || !s.csrfOK(w, r) {105
return106
return106
}107
}107
body := r.FormValue("body")108
out, err := s.opLintCI(r, repo, r.FormValue("body"), r.FormValue("ref"))108
if len(body) > ciMaxBytes {109
if err != nil {109
http.Error(w, s.tr(r, "edit.fail"), http.StatusBadRequest)110
http.Error(w, s.trErr(r, err), statusOf(err))110
return111
return111
}112
}112
ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)113
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)114
model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))115
lines := make([]string, len(model.Rows))116
var bad []int117
for i, row := range model.Rows {118
lines[i] = string(row.HTML)119
if row.Bad {120
bad = append(bad, row.N)121
}122
}123
w.Header().Set("Content-Type", "application/json")113
w.Header().Set("Content-Type", "application/json")124
_ = json.NewEncoder(w).Encode(map[string]any{114
_ = json.NewEncoder(w).Encode(out)125
"status": model.Status,126
"statusClass": model.Class,127
"errors": model.Errors,128
"warnings": model.Warnings,129
"issues": model.Issues,130
"lines": lines,131
"bad": bad,132
})133
}115
}134
116
135
func (s *Server) saveCIEditor(w http.ResponseWriter, r *http.Request) {117
func (s *Server) saveCIEditor(w http.ResponseWriter, r *http.Request) {136
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)118
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)137
if !ok || !s.csrfOK(w, r) {119
if !ok || !s.csrfOK(w, r) {138
return120
return139
}121
}140
base := safeRev(r.FormValue("base"), repo.DefaultBranch)141
branch := strings.TrimSpace(r.FormValue("branch"))122
branch := strings.TrimSpace(r.FormValue("branch"))142
if !validBranchName(branch) {123
base := r.FormValue("base")143
s.redirect(w, r, repoURL(repo)+"/-/ci/editor?ref="+url.QueryEscape(base), "", s.tr(r, "edit.badBranch"))144
return145
}146
back := repoURL(repo) + "/-/ci/editor?ref=" + url.QueryEscape(branch)124
back := repoURL(repo) + "/-/ci/editor?ref=" + url.QueryEscape(branch)147
message := strings.TrimSpace(r.FormValue("message"))148
if message == "" {149
s.redirect(w, r, back, "", s.tr(r, "edit.needMessage"))150
return151
}152
body := r.FormValue("body")153
if len(body) > ciMaxBytes {154
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))155
return156
}157
openMR := r.FormValue("open_mr") == "1"125
openMR := r.FormValue("open_mr") == "1"158
patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)126
_, number, err := s.opSaveCI(r.Context(), u, repo, base, branch, r.FormValue("message"), r.FormValue("body"), openMR)159
if openMR && (branch == base || access.BranchProtected(patterns, branch)) {160
s.redirect(w, r, back, "", s.tr(r, "edit.badBranch"))161
return162
}163
if access.BranchProtected(patterns, branch) && !role.CanPushBranch(true) {164
s.redirect(w, r, back, "", s.tr(r, "edit.protected"))165
return166
}167
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)168
work, err := s.scratchDir("ci-edit")169
if err != nil {170
s.redirect(w, r, back, "", s.commitProblem(r, err))171
return172
}173
defer os.RemoveAll(work)174
if err := s.ensureBranch(r, dir, branch, base, work); err != nil {175
s.redirect(w, r, back, "", s.commitProblem(r, err))176
return177
}178
email := u.Username + "@users.git.timfalken.com"179
err = s.postReceive(r.Context(), repo, u, dir, func() error {180
return gitrepo.CommitOnBranch(r.Context(), s.Git, dir, work, branch, u.Username, email, message, "", map[string]string{ciFile: body}, role, patterns)181
})182
if err != nil {127
if err != nil {128
if strings.TrimSpace(branch) == "" || !validBranchName(branch) {129
back = repoURL(repo) + "/-/ci/editor?ref=" + url.QueryEscape(safeRev(base, repo.DefaultBranch))130
}183
s.redirect(w, r, back, "", s.commitProblem(r, err))131
s.redirect(w, r, back, "", s.commitProblem(r, err))184
return132
return185
}133
}186
if openMR {134
if openMR && number > 0 {187
number, mrErr := s.openCIMergeRequest(r, repo, u, dir, branch, base, message)188
if mrErr != nil {189
if s.Log != nil {190
s.Log.Error("ci-editor-mr", "err", mrErr)191
}192
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))193
return194
}195
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(number, 10), s.tr(r, "flash.mrOpened"), "")135
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(number, 10), s.tr(r, "flash.mrOpened"), "")196
return136
return197
}137
}@@ -312,17 +252,17 @@ func (s *Server) includeFrom(r *http.Request, dir, ref string) func(string) ([]b312
}252
}313
}253
}314
254
315
func (s *Server) ensureBranch(r *http.Request, dir, branch, base, work string) error {255
func (s *Server) ensureBranch(ctx context.Context, dir, branch, base, work string) error {316
home := filepath.Join(work, "home")256
home := filepath.Join(work, "home")317
if err := os.MkdirAll(home, 0o700); err != nil {257
if err := os.MkdirAll(home, 0o700); err != nil {318
return gitrepo.Cause("edit.failWrite", err.Error())258
return gitrepo.Cause("edit.failWrite", err.Error())319
}259
}320
env := gitrepo.CommandEnv("bluegit", "bluegit@users.git.timfalken.com", home, home)260
env := gitrepo.CommandEnv("bluegit", "bluegit@users.git.timfalken.com", home, home)321
if s.gitEnv(r, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch) != "" {261
if s.gitEnv(ctx, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch) != "" {322
return nil262
return nil323
}263
}324
if s.gitEnv(r, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+base) != "" {264
if s.gitEnv(ctx, dir, env, "rev-parse", "--verify", "--quiet", "refs/heads/"+base) != "" {325
cmd := exec.CommandContext(r.Context(), s.Git, "-C", dir, "branch", branch, base)265
cmd := exec.CommandContext(ctx, s.Git, "-C", dir, "branch", branch, base)326
cmd.Env = env266
cmd.Env = env327
if out, err := cmd.CombinedOutput(); err != nil {267
if out, err := cmd.CombinedOutput(); err != nil {328
return gitrepo.Cause("edit.failBranch", strings.TrimSpace(string(out)))268
return gitrepo.Cause("edit.failBranch", strings.TrimSpace(string(out)))@@ -331,18 +271,18 @@ func (s *Server) ensureBranch(r *http.Request, dir, branch, base, work string) e331
}271
}332
// Nog geen enkele commit. De gekozen branch wordt de eerste, zonder parent.272
// Nog geen enkele commit. De gekozen branch wordt de eerste, zonder parent.333
// Een beheerder, ook de eigenaar, mag dat ook op een beschermde branch.273
// Een beheerder, ook de eigenaar, mag dat ook op een beschermde branch.334
if s.gitEnv(r, dir, env, "rev-parse", "--verify", "--quiet", "HEAD") == "" {274
if s.gitEnv(ctx, dir, env, "rev-parse", "--verify", "--quiet", "HEAD") == "" {335
return nil275
return nil336
}276
}337
return i18n.E("edit.failBranch")277
return i18n.E("edit.failBranch")338
}278
}339
279
340
func (s *Server) gitEnv(r *http.Request, dir string, env []string, args ...string) string {280
func (s *Server) gitEnv(ctx context.Context, dir string, env []string, args ...string) string {341
bin := s.Git281
bin := s.Git342
if bin == "" {282
if bin == "" {343
bin = "git"283
bin = "git"344
}284
}345
cmd := exec.CommandContext(r.Context(), bin, append([]string{"-C", dir}, args...)...)285
cmd := exec.CommandContext(ctx, bin, append([]string{"-C", dir}, args...)...)346
cmd.Env = env286
cmd.Env = env347
out, err := cmd.Output()287
out, err := cmd.Output()348
if err != nil {288
if err != nil {@@ -28,7 +28,7 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
28
28
}
29
29
service := r.URL.Query().Get("service")
30
30
write := service == "git-receive-pack" || strings.HasSuffix(r.URL.Path, "/git-receive-pack")
31
user, authed := s.gitUser(r)
31
user, scopes, authed := s.gitUser(r)
32
32
var role access.Role
33
33
if authed {
34
34
role, err = s.Store.EffectiveRole(r.Context(), user.ID, repo.ID)
@@ -42,6 +42,10 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
42
42
s.askAuth(w)
43
43
return
44
44
}
45
if !scopes.RepoWrite() {
46
http.Error(w, s.tr(r, "err.apiScope"), http.StatusForbidden)
47
return
48
}
45
49
if !role.CanWriteCode() {
46
50
http.Error(w, s.tr(r, "err.noWrite"), http.StatusForbidden)
47
51
return
@@ -53,6 +57,9 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
53
57
}
54
58
http.Error(w, s.tr(r, "err.noRead"), http.StatusForbidden)
55
59
return
60
} else if authed && !scopes.RepoRead() {
61
http.Error(w, s.tr(r, "err.apiScope"), http.StatusForbidden)
62
return
56
63
}
57
64
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
58
65
var before map[string]string
@@ -76,7 +83,7 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {
76
83
}
77
84
}
78
85
79
func (s *Server) gitUser(r *http.Request) (store.User, bool) {
86
func (s *Server) gitUser(r *http.Request) (store.User, access.Scopes, bool) {
80
87
_, pass, ok := r.BasicAuth()
81
88
if !ok {
82
89
h := r.Header.Get("Authorization")
@@ -86,10 +93,13 @@ func (s *Server) gitUser(r *http.Request) (store.User, bool) {
86
93
}
87
94
}
88
95
if !ok || !strings.HasPrefix(pass, "bg_") {
89
return store.User{}, false
96
return store.User{}, access.Scopes{}, false
97
}
98
auth, err := s.Store.AuthenticateToken(r.Context(), pass)
99
if err != nil {
100
return store.User{}, access.Scopes{}, false
90
101
}
91
u, err := s.Store.UserByToken(r.Context(), pass)
92
return u, err == nil
102
return auth.User, access.StoredScopes(auth.Token.Scopes), true
93
103
}
94
104
95
105
func (s *Server) askAuth(w http.ResponseWriter) {
@@ -28,7 +28,7 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {28
}28
}29
service := r.URL.Query().Get("service")29
service := r.URL.Query().Get("service")30
write := service == "git-receive-pack" || strings.HasSuffix(r.URL.Path, "/git-receive-pack")30
write := service == "git-receive-pack" || strings.HasSuffix(r.URL.Path, "/git-receive-pack")31
user, authed := s.gitUser(r)31
user, scopes, authed := s.gitUser(r)32
var role access.Role32
var role access.Role33
if authed {33
if authed {34
role, err = s.Store.EffectiveRole(r.Context(), user.ID, repo.ID)34
role, err = s.Store.EffectiveRole(r.Context(), user.ID, repo.ID)@@ -42,6 +42,10 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {42
s.askAuth(w)42
s.askAuth(w)43
return43
return44
}44
}45
if !scopes.RepoWrite() {46
http.Error(w, s.tr(r, "err.apiScope"), http.StatusForbidden)47
return48
}45
if !role.CanWriteCode() {49
if !role.CanWriteCode() {46
http.Error(w, s.tr(r, "err.noWrite"), http.StatusForbidden)50
http.Error(w, s.tr(r, "err.noWrite"), http.StatusForbidden)47
return51
return@@ -53,6 +57,9 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {53
}57
}54
http.Error(w, s.tr(r, "err.noRead"), http.StatusForbidden)58
http.Error(w, s.tr(r, "err.noRead"), http.StatusForbidden)55
return59
return60
} else if authed && !scopes.RepoRead() {61
http.Error(w, s.tr(r, "err.apiScope"), http.StatusForbidden)62
return56
}63
}57
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)64
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)58
var before map[string]string65
var before map[string]string@@ -76,7 +83,7 @@ func (s *Server) gitHTTP(w http.ResponseWriter, r *http.Request) {76
}83
}77
}84
}78
85
79
func (s *Server) gitUser(r *http.Request) (store.User, bool) {86
func (s *Server) gitUser(r *http.Request) (store.User, access.Scopes, bool) {80
_, pass, ok := r.BasicAuth()87
_, pass, ok := r.BasicAuth()81
if !ok {88
if !ok {82
h := r.Header.Get("Authorization")89
h := r.Header.Get("Authorization")@@ -86,10 +93,13 @@ func (s *Server) gitUser(r *http.Request) (store.User, bool) {86
}93
}87
}94
}88
if !ok || !strings.HasPrefix(pass, "bg_") {95
if !ok || !strings.HasPrefix(pass, "bg_") {89
return store.User{}, false96
return store.User{}, access.Scopes{}, false97
}98
auth, err := s.Store.AuthenticateToken(r.Context(), pass)99
if err != nil {100
return store.User{}, access.Scopes{}, false90
}101
}91
u, err := s.Store.UserByToken(r.Context(), pass)102
return auth.User, access.StoredScopes(auth.Token.Scopes), true92
return u, err == nil93
}103
}94
104
95
func (s *Server) askAuth(w http.ResponseWriter) {105
func (s *Server) askAuth(w http.ResponseWriter) {@@ -20,6 +20,7 @@ func (s *Server) infoPage(w http.ResponseWriter, r *http.Request) {
20
20
v.Info = true
21
21
v.Spec = doc
22
22
v.SpecJSON = template.JS(raw)
23
v.APIJSON = template.JS(apiIndex())
23
24
s.attachUpdate(&v, s.langOf(r))
24
25
s.render(w, "info", v)
25
26
}
@@ -20,6 +20,7 @@ func (s *Server) infoPage(w http.ResponseWriter, r *http.Request) {20
v.Info = true20
v.Info = true21
v.Spec = doc21
v.Spec = doc22
v.SpecJSON = template.JS(raw)22
v.SpecJSON = template.JS(raw)23
v.APIJSON = template.JS(apiIndex())23
s.attachUpdate(&v, s.langOf(r))24
s.attachUpdate(&v, s.langOf(r))24
s.render(w, "info", v)25
s.render(w, "info", v)25
}26
}@@ -34,6 +34,9 @@ func TestCISpecPageMatchesAPI(t *testing.T) {
34
34
"workflow",
35
35
"Differences with GitLab",
36
36
`href="/-/info"`,
37
`id="bluegit-api"`,
38
`href="/api/v1/openapi.json"`,
39
"PRIVATE-TOKEN",
37
40
} {
38
41
if !strings.Contains(body, want) {
39
42
t.Fatalf("mist %q", want)
@@ -34,6 +34,9 @@ func TestCISpecPageMatchesAPI(t *testing.T) {34
"workflow",34
"workflow",35
"Differences with GitLab",35
"Differences with GitLab",36
`href="/-/info"`,36
`href="/-/info"`,37
`id="bluegit-api"`,38
`href="/api/v1/openapi.json"`,39
"PRIVATE-TOKEN",37
} {40
} {38
if !strings.Contains(body, want) {41
if !strings.Contains(body, want) {39
t.Fatalf("mist %q", want)42
t.Fatalf("mist %q", want)@@ -59,8 +59,8 @@ func (s *Server) saveLanguage(w http.ResponseWriter, r *http.Request) {
59
59
if !ok || !s.csrfOK(w, r) {
60
60
return
61
61
}
62
lang := i18n.Parse(r.FormValue("language"))
63
if err := s.Store.SetLanguage(r.Context(), u.ID, string(lang)); err != nil {
62
lang, err := s.opSetLanguage(r.Context(), u, r.FormValue("language"))
63
if err != nil {
64
64
s.redirect(w, r, "/settings", "", s.trErr(r, err))
65
65
return
66
66
}
@@ -72,21 +72,8 @@ func (s *Server) saveGroup(w http.ResponseWriter, r *http.Request) {
72
72
if !ok || !s.csrfOK(w, r) {
73
73
return
74
74
}
75
vis := r.FormValue("visibility")
76
if vis != "public" {
77
vis = "private"
78
}
79
role := g.DefaultRole
80
if raw := strings.TrimSpace(r.FormValue("default_role")); raw != "" {
81
parsed, err := access.ParseRole(raw)
82
if err != nil {
83
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))
84
return
85
}
86
role = parsed
87
}
88
if err := s.Store.UpdateGroup(r.Context(), g.ID, r.FormValue("description"), vis, role); err != nil {
89
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))
75
if err := s.opUpdateGroup(r.Context(), s.who(r).User, g, r.FormValue("description"), r.FormValue("visibility"), r.FormValue("default_role")); err != nil {
76
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.commitProblem(r, err))
90
77
return
91
78
}
92
79
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "")
@@ -97,18 +84,10 @@ func (s *Server) toggleStar(w http.ResponseWriter, r *http.Request) {
97
84
if !ok || !s.csrfOK(w, r) {
98
85
return
99
86
}
100
if u.ID == 0 {
101
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
102
return
103
}
104
_, mine, err := s.Store.StarInfo(r.Context(), u.ID, []int64{repo.ID})
105
if err != nil {
106
s.redirect(w, r, repoURL(repo), "", s.trErr(r, err))
107
return
108
}
109
if err := s.Store.SetStar(r.Context(), u.ID, repo.ID, !mine[repo.ID]); err != nil {
110
s.redirect(w, r, repoURL(repo), "", s.trErr(r, err))
111
return
87
if _, err := s.opToggleStar(r.Context(), u, repo); err != nil {
88
if !s.uiOK(w, r, repoURL(repo), err) {
89
return
90
}
112
91
}
113
92
back := r.FormValue("back")
114
93
if !strings.HasPrefix(back, "/") || strings.HasPrefix(back, "//") || strings.Contains(back, "://") {
@@ -59,8 +59,8 @@ func (s *Server) saveLanguage(w http.ResponseWriter, r *http.Request) {59
if !ok || !s.csrfOK(w, r) {59
if !ok || !s.csrfOK(w, r) {60
return60
return61
}61
}62
lang := i18n.Parse(r.FormValue("language"))62
lang, err := s.opSetLanguage(r.Context(), u, r.FormValue("language"))63
if err := s.Store.SetLanguage(r.Context(), u.ID, string(lang)); err != nil {63
if err != nil {64
s.redirect(w, r, "/settings", "", s.trErr(r, err))64
s.redirect(w, r, "/settings", "", s.trErr(r, err))65
return65
return66
}66
}@@ -72,21 +72,8 @@ func (s *Server) saveGroup(w http.ResponseWriter, r *http.Request) {72
if !ok || !s.csrfOK(w, r) {72
if !ok || !s.csrfOK(w, r) {73
return73
return74
}74
}75
vis := r.FormValue("visibility")75
if err := s.opUpdateGroup(r.Context(), s.who(r).User, g, r.FormValue("description"), r.FormValue("visibility"), r.FormValue("default_role")); err != nil {76
if vis != "public" {76
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.commitProblem(r, err))77
vis = "private"78
}79
role := g.DefaultRole80
if raw := strings.TrimSpace(r.FormValue("default_role")); raw != "" {81
parsed, err := access.ParseRole(raw)82
if err != nil {83
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))84
return85
}86
role = parsed87
}88
if err := s.Store.UpdateGroup(r.Context(), g.ID, r.FormValue("description"), vis, role); err != nil {89
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))90
return77
return91
}78
}92
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "")79
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", s.tr(r, "flash.saved"), "")@@ -97,18 +84,10 @@ func (s *Server) toggleStar(w http.ResponseWriter, r *http.Request) {97
if !ok || !s.csrfOK(w, r) {84
if !ok || !s.csrfOK(w, r) {98
return85
return99
}86
}100
if u.ID == 0 {87
if _, err := s.opToggleStar(r.Context(), u, repo); err != nil {101
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)88
if !s.uiOK(w, r, repoURL(repo), err) {102
return89
return103
}90
}104
_, mine, err := s.Store.StarInfo(r.Context(), u.ID, []int64{repo.ID})105
if err != nil {106
s.redirect(w, r, repoURL(repo), "", s.trErr(r, err))107
return108
}109
if err := s.Store.SetStar(r.Context(), u.ID, repo.ID, !mine[repo.ID]); err != nil {110
s.redirect(w, r, repoURL(repo), "", s.trErr(r, err))111
return112
}91
}113
back := r.FormValue("back")92
back := r.FormValue("back")114
if !strings.HasPrefix(back, "/") || strings.HasPrefix(back, "//") || strings.Contains(back, "://") {93
if !strings.HasPrefix(back, "/") || strings.HasPrefix(back, "//") || strings.Contains(back, "://") {@@ -79,33 +79,19 @@ func (s *Server) previewMarkdown(w http.ResponseWriter, r *http.Request) {
79
79
}
80
80
81
81
func (s *Server) updateMR(w http.ResponseWriter, r *http.Request) {
82
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
82
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
83
83
if !ok || !s.csrfOK(w, r) {
84
84
return
85
85
}
86
mr, err := s.mrFromRequest(r, repo.ID)
86
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
87
87
if err != nil {
88
88
http.NotFound(w, r)
89
89
return
90
90
}
91
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
92
if mr.Status != "open" || u.ID == 0 || (u.ID != mr.AuthorID && !role.CanWriteCode()) {
93
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
94
return
95
}
96
title := strings.TrimSpace(r.FormValue("title"))
97
description := r.FormValue("description")
98
labels := normalizeLabels(r.FormValue("labels"))
99
if err := s.Store.UpdateMergeRequest(r.Context(), mr.ID, title, description, labels); err != nil {
100
s.redirect(w, r, back, "", s.trErr(r, err))
91
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
92
if _, err := s.opUpdateMR(r.Context(), u, repo, n, r.FormValue("title"), r.FormValue("description"), r.FormValue("labels")); !s.uiOK(w, r, back, err) {
101
93
return
102
94
}
103
if title != mr.Title {
104
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "retitled", title)
105
}
106
if labels != normalizeLabels(mr.Labels) {
107
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "relabeled", labels)
108
}
109
95
s.redirect(w, r, back, s.tr(r, "flash.mrUpdated"), "")
110
96
}
111
97
@@ -79,33 +79,19 @@ func (s *Server) previewMarkdown(w http.ResponseWriter, r *http.Request) {79
}79
}80
80
81
func (s *Server) updateMR(w http.ResponseWriter, r *http.Request) {81
func (s *Server) updateMR(w http.ResponseWriter, r *http.Request) {82
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)82
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)83
if !ok || !s.csrfOK(w, r) {83
if !ok || !s.csrfOK(w, r) {84
return84
return85
}85
}86
mr, err := s.mrFromRequest(r, repo.ID)86
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)87
if err != nil {87
if err != nil {88
http.NotFound(w, r)88
http.NotFound(w, r)89
return89
return90
}90
}91
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)91
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")92
if mr.Status != "open" || u.ID == 0 || (u.ID != mr.AuthorID && !role.CanWriteCode()) {92
if _, err := s.opUpdateMR(r.Context(), u, repo, n, r.FormValue("title"), r.FormValue("description"), r.FormValue("labels")); !s.uiOK(w, r, back, err) {93
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)94
return95
}96
title := strings.TrimSpace(r.FormValue("title"))97
description := r.FormValue("description")98
labels := normalizeLabels(r.FormValue("labels"))99
if err := s.Store.UpdateMergeRequest(r.Context(), mr.ID, title, description, labels); err != nil {100
s.redirect(w, r, back, "", s.trErr(r, err))101
return93
return102
}94
}103
if title != mr.Title {104
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "retitled", title)105
}106
if labels != normalizeLabels(mr.Labels) {107
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "relabeled", labels)108
}109
s.redirect(w, r, back, s.tr(r, "flash.mrUpdated"), "")95
s.redirect(w, r, back, s.tr(r, "flash.mrUpdated"), "")110
}96
}111
97
@@ -0,0 +1,87 @@
1
package server
2
3
import (
4
"errors"
5
"net/http"
6
7
"gitlab.com/Timfa/bluegit/internal/i18n"
8
"gitlab.com/Timfa/bluegit/internal/store"
9
)
10
11
// opError is een fout uit de gedeelde servicelaag, met een HTTP-status.
12
type opError struct {
13
status int
14
err error
15
}
16
17
func (e *opError) Error() string {
18
if e == nil || e.err == nil {
19
return ""
20
}
21
return e.err.Error()
22
}
23
24
func (e *opError) Unwrap() error {
25
if e == nil {
26
return nil
27
}
28
return e.err
29
}
30
31
func fail(status int, err error) error {
32
if err == nil {
33
err = errors.New(http.StatusText(status))
34
}
35
return &opError{status: status, err: err}
36
}
37
38
func statusOf(err error) int {
39
var oe *opError
40
if errors.As(err, &oe) && oe.status != 0 {
41
return oe.status
42
}
43
if store.IsNotFound(err) {
44
return http.StatusNotFound
45
}
46
return http.StatusBadRequest
47
}
48
49
func (s *Server) uiOK(w http.ResponseWriter, r *http.Request, back string, err error) bool {
50
if err == nil {
51
return true
52
}
53
st := statusOf(err)
54
if st == http.StatusNotFound {
55
http.NotFound(w, r)
56
return false
57
}
58
if st == http.StatusForbidden || st == http.StatusUnauthorized || st == http.StatusInternalServerError {
59
http.Error(w, s.trErr(r, err), st)
60
return false
61
}
62
s.redirect(w, r, back, "", s.commitProblem(r, err))
63
return false
64
}
65
66
func (s *Server) uiFail(w http.ResponseWriter, r *http.Request, back string, err error) {
67
st := statusOf(err)
68
if st == http.StatusForbidden || st == http.StatusUnauthorized || st == http.StatusInternalServerError {
69
http.Error(w, s.trErr(r, err), st)
70
return
71
}
72
s.redirect(w, r, back, "", s.trErr(r, err))
73
}
74
75
func userEmail(name string) string {
76
return name + "@users.git.timfalken.com"
77
}
78
79
func notFound(err error) error {
80
if err == nil {
81
return fail(http.StatusNotFound, i18n.E("err.notFound"))
82
}
83
if store.IsNotFound(err) {
84
return fail(http.StatusNotFound, i18n.E("err.notFound"))
85
}
86
return fail(http.StatusBadRequest, err)
87
}
@@ -0,0 +1,87 @@1
package server2
3
import (4
"errors"5
"net/http"6
7
"gitlab.com/Timfa/bluegit/internal/i18n"8
"gitlab.com/Timfa/bluegit/internal/store"9
)10
11
// opError is een fout uit de gedeelde servicelaag, met een HTTP-status.12
type opError struct {13
status int14
err error15
}16
17
func (e *opError) Error() string {18
if e == nil || e.err == nil {19
return ""20
}21
return e.err.Error()22
}23
24
func (e *opError) Unwrap() error {25
if e == nil {26
return nil27
}28
return e.err29
}30
31
func fail(status int, err error) error {32
if err == nil {33
err = errors.New(http.StatusText(status))34
}35
return &opError{status: status, err: err}36
}37
38
func statusOf(err error) int {39
var oe *opError40
if errors.As(err, &oe) && oe.status != 0 {41
return oe.status42
}43
if store.IsNotFound(err) {44
return http.StatusNotFound45
}46
return http.StatusBadRequest47
}48
49
func (s *Server) uiOK(w http.ResponseWriter, r *http.Request, back string, err error) bool {50
if err == nil {51
return true52
}53
st := statusOf(err)54
if st == http.StatusNotFound {55
http.NotFound(w, r)56
return false57
}58
if st == http.StatusForbidden || st == http.StatusUnauthorized || st == http.StatusInternalServerError {59
http.Error(w, s.trErr(r, err), st)60
return false61
}62
s.redirect(w, r, back, "", s.commitProblem(r, err))63
return false64
}65
66
func (s *Server) uiFail(w http.ResponseWriter, r *http.Request, back string, err error) {67
st := statusOf(err)68
if st == http.StatusForbidden || st == http.StatusUnauthorized || st == http.StatusInternalServerError {69
http.Error(w, s.trErr(r, err), st)70
return71
}72
s.redirect(w, r, back, "", s.trErr(r, err))73
}74
75
func userEmail(name string) string {76
return name + "@users.git.timfalken.com"77
}78
79
func notFound(err error) error {80
if err == nil {81
return fail(http.StatusNotFound, i18n.E("err.notFound"))82
}83
if store.IsNotFound(err) {84
return fail(http.StatusNotFound, i18n.E("err.notFound"))85
}86
return fail(http.StatusBadRequest, err)87
}@@ -0,0 +1,109 @@
1
package server
2
3
import (
4
"context"
5
"strings"
6
"time"
7
8
"gitlab.com/Timfa/bluegit/internal/access"
9
"gitlab.com/Timfa/bluegit/internal/i18n"
10
"gitlab.com/Timfa/bluegit/internal/store"
11
"golang.org/x/crypto/ssh"
12
)
13
14
func (s *Server) opIssueToken(ctx context.Context, user store.User, name string, scopes []string, expires time.Time) (string, store.TokenInfo, error) {
15
stored, _, err := access.ParseScopes(scopes)
16
if err != nil {
17
return "", store.TokenInfo{}, fail(400, err)
18
}
19
plain, info, err := s.Store.IssueToken(ctx, user.ID, store.TokenRequest{Name: name, Scopes: stored, ExpiresAt: expires})
20
if err != nil {
21
return "", store.TokenInfo{}, fail(400, err)
22
}
23
return plain, info, nil
24
}
25
26
func (s *Server) opRevokeToken(ctx context.Context, user store.User, id int64) error {
27
if err := s.Store.DeleteToken(ctx, user.ID, id); err != nil {
28
return notFound(err)
29
}
30
return nil
31
}
32
33
func (s *Server) opAddSSH(ctx context.Context, user store.User, name, line string) error {
34
line = strings.TrimSpace(line)
35
pub, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))
36
if err != nil {
37
return fail(400, i18n.E("err.sshBad"))
38
}
39
stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))
40
if err := s.Store.AddSSHKey(ctx, user.ID, name, stored, ssh.FingerprintSHA256(pub)); err != nil {
41
return fail(400, err)
42
}
43
return nil
44
}
45
46
func (s *Server) opRemoveSSH(ctx context.Context, user store.User, id int64) error {
47
if err := s.Store.DeleteSSHKey(ctx, user.ID, id); err != nil {
48
return notFound(err)
49
}
50
return nil
51
}
52
53
func (s *Server) opSetLanguage(ctx context.Context, user store.User, raw string) (i18n.Lang, error) {
54
lang := i18n.Parse(raw)
55
if err := s.Store.SetLanguage(ctx, user.ID, string(lang)); err != nil {
56
return lang, fail(400, err)
57
}
58
return lang, nil
59
}
60
61
func (s *Server) opExport(ctx context.Context, u store.User) map[string]any {
62
type secretRow struct {
63
Scope string `json:"scope"`
64
Name string `json:"name"`
65
Value string `json:"value"`
66
}
67
var secrets []secretRow
68
ids, _ := s.Store.ListRepoIDs(ctx, u.ID)
69
for _, id := range ids {
70
role, err := s.Store.EffectiveRole(ctx, u.ID, id)
71
if err != nil || !role.CanManageSecrets() {
72
continue
73
}
74
repo, err := s.Store.RepoByID(ctx, id)
75
if err != nil {
76
continue
77
}
78
vals, err := s.Store.SecretValues(ctx, "repo", id, true)
79
if err != nil {
80
continue
81
}
82
for name, value := range vals {
83
secrets = append(secrets, secretRow{Scope: "repo:" + repo.FullPath(), Name: name, Value: value})
84
}
85
}
86
groups, _ := s.Store.ListGroups(ctx, u.ID)
87
for _, g := range groups {
88
role, err := s.Store.GroupRole(ctx, g.ID, u.ID)
89
if err != nil || !role.AtLeast(access.RoleMaintainer) {
90
continue
91
}
92
vals, err := s.Store.SecretValues(ctx, "group", g.ID, true)
93
if err != nil {
94
continue
95
}
96
for name, value := range vals {
97
secrets = append(secrets, secretRow{Scope: "group:" + g.Path, Name: name, Value: value})
98
}
99
}
100
tokens, _ := s.Store.ListTokens(ctx, u.ID)
101
keys, _ := s.Store.ListSSHKeys(ctx, u.ID)
102
return map[string]any{
103
"exported_at": time.Now().UTC().Format(time.RFC3339),
104
"account": map[string]any{
105
"id": u.AuthID, "username": u.Username, "avatar_url": u.AvatarURL, "instance_admin": u.InstanceAdmin,
106
},
107
"tokens": tokens, "ssh_keys": keys, "secrets": secrets,
108
}
109
}
@@ -0,0 +1,109 @@1
package server2
3
import (4
"context"5
"strings"6
"time"7
8
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/i18n"10
"gitlab.com/Timfa/bluegit/internal/store"11
"golang.org/x/crypto/ssh"12
)13
14
func (s *Server) opIssueToken(ctx context.Context, user store.User, name string, scopes []string, expires time.Time) (string, store.TokenInfo, error) {15
stored, _, err := access.ParseScopes(scopes)16
if err != nil {17
return "", store.TokenInfo{}, fail(400, err)18
}19
plain, info, err := s.Store.IssueToken(ctx, user.ID, store.TokenRequest{Name: name, Scopes: stored, ExpiresAt: expires})20
if err != nil {21
return "", store.TokenInfo{}, fail(400, err)22
}23
return plain, info, nil24
}25
26
func (s *Server) opRevokeToken(ctx context.Context, user store.User, id int64) error {27
if err := s.Store.DeleteToken(ctx, user.ID, id); err != nil {28
return notFound(err)29
}30
return nil31
}32
33
func (s *Server) opAddSSH(ctx context.Context, user store.User, name, line string) error {34
line = strings.TrimSpace(line)35
pub, _, _, _, err := ssh.ParseAuthorizedKey([]byte(line))36
if err != nil {37
return fail(400, i18n.E("err.sshBad"))38
}39
stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))40
if err := s.Store.AddSSHKey(ctx, user.ID, name, stored, ssh.FingerprintSHA256(pub)); err != nil {41
return fail(400, err)42
}43
return nil44
}45
46
func (s *Server) opRemoveSSH(ctx context.Context, user store.User, id int64) error {47
if err := s.Store.DeleteSSHKey(ctx, user.ID, id); err != nil {48
return notFound(err)49
}50
return nil51
}52
53
func (s *Server) opSetLanguage(ctx context.Context, user store.User, raw string) (i18n.Lang, error) {54
lang := i18n.Parse(raw)55
if err := s.Store.SetLanguage(ctx, user.ID, string(lang)); err != nil {56
return lang, fail(400, err)57
}58
return lang, nil59
}60
61
func (s *Server) opExport(ctx context.Context, u store.User) map[string]any {62
type secretRow struct {63
Scope string `json:"scope"`64
Name string `json:"name"`65
Value string `json:"value"`66
}67
var secrets []secretRow68
ids, _ := s.Store.ListRepoIDs(ctx, u.ID)69
for _, id := range ids {70
role, err := s.Store.EffectiveRole(ctx, u.ID, id)71
if err != nil || !role.CanManageSecrets() {72
continue73
}74
repo, err := s.Store.RepoByID(ctx, id)75
if err != nil {76
continue77
}78
vals, err := s.Store.SecretValues(ctx, "repo", id, true)79
if err != nil {80
continue81
}82
for name, value := range vals {83
secrets = append(secrets, secretRow{Scope: "repo:" + repo.FullPath(), Name: name, Value: value})84
}85
}86
groups, _ := s.Store.ListGroups(ctx, u.ID)87
for _, g := range groups {88
role, err := s.Store.GroupRole(ctx, g.ID, u.ID)89
if err != nil || !role.AtLeast(access.RoleMaintainer) {90
continue91
}92
vals, err := s.Store.SecretValues(ctx, "group", g.ID, true)93
if err != nil {94
continue95
}96
for name, value := range vals {97
secrets = append(secrets, secretRow{Scope: "group:" + g.Path, Name: name, Value: value})98
}99
}100
tokens, _ := s.Store.ListTokens(ctx, u.ID)101
keys, _ := s.Store.ListSSHKeys(ctx, u.ID)102
return map[string]any{103
"exported_at": time.Now().UTC().Format(time.RFC3339),104
"account": map[string]any{105
"id": u.AuthID, "username": u.Username, "avatar_url": u.AvatarURL, "instance_admin": u.InstanceAdmin,106
},107
"tokens": tokens, "ssh_keys": keys, "secrets": secrets,108
}109
}@@ -0,0 +1,257 @@
1
package server
2
3
import (
4
"context"
5
"net/http"
6
"os"
7
"path/filepath"
8
"strings"
9
10
"gitlab.com/Timfa/bluegit/internal/access"
11
"gitlab.com/Timfa/bluegit/internal/gitrepo"
12
"gitlab.com/Timfa/bluegit/internal/i18n"
13
"gitlab.com/Timfa/bluegit/internal/names"
14
"gitlab.com/Timfa/bluegit/internal/store"
15
"gitlab.com/Timfa/bluegit/internal/webhook"
16
)
17
18
func (s *Server) opRunPipeline(ctx context.Context, user store.User, repo store.Repo, ref, source string) (int64, error) {
19
role, err := s.repoRole(ctx, user, repo)
20
if err != nil {
21
return 0, err
22
}
23
if !role.CanWriteCode() {
24
return 0, fail(403, i18n.E("err.forbidden"))
25
}
26
ref = safeRev(ref, repo.DefaultBranch)
27
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
28
sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", ref+"^{commit}")
29
if sha == "" {
30
return 0, fail(400, i18n.E("err.branchMissing"))
31
}
32
if source == "" {
33
source = "api"
34
}
35
id := s.startPipeline(ctx, repo, sha, "refs/heads/"+ref, user.Username, source, "", nil)
36
return id, nil
37
}
38
39
func (s *Server) opJobAction(ctx context.Context, user store.User, repo store.Repo, pipeID, jobID int64, action string) (store.Job, error) {
40
role, err := s.repoRole(ctx, user, repo)
41
if err != nil {
42
return store.Job{}, err
43
}
44
if !role.CanWriteCode() {
45
return store.Job{}, fail(403, i18n.E("err.forbidden"))
46
}
47
p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
48
if err != nil {
49
return store.Job{}, notFound(err)
50
}
51
jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
52
var job store.Job
53
found := false
54
for _, j := range jobs {
55
if j.ID == jobID {
56
job = j
57
found = true
58
break
59
}
60
}
61
if !found {
62
return store.Job{}, fail(404, i18n.E("err.notFound"))
63
}
64
switch action {
65
case "play":
66
ok, err := s.Store.QueueJob(ctx, job.ID)
67
if err != nil {
68
return store.Job{}, fail(400, err)
69
}
70
if !ok {
71
return store.Job{}, fail(409, i18n.E("err.jobState"))
72
}
73
case "retry":
74
ok, err := s.Store.RetryJob(ctx, job.ID)
75
if err != nil {
76
return store.Job{}, fail(400, err)
77
}
78
if !ok {
79
return store.Job{}, fail(409, i18n.E("err.jobState"))
80
}
81
case "cancel":
82
ok, err := s.Store.CancelJob(ctx, job.ID)
83
if err != nil {
84
return store.Job{}, fail(400, err)
85
}
86
if !ok {
87
return store.Job{}, fail(409, i18n.E("err.jobState"))
88
}
89
if s.Runner != nil {
90
s.Runner.Interrupt([]int64{job.ID})
91
}
92
_, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)
93
default:
94
return store.Job{}, fail(400, i18n.E("err.jobState"))
95
}
96
jobs, _ = s.Store.JobsByPipeline(ctx, p.ID)
97
for _, j := range jobs {
98
if j.ID == jobID {
99
return j, nil
100
}
101
}
102
return job, nil
103
}
104
105
func (s *Server) opCancelPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64) error {
106
role, err := s.repoRole(ctx, user, repo)
107
if err != nil {
108
return err
109
}
110
if !role.CanWriteCode() {
111
return fail(403, i18n.E("err.forbidden"))
112
}
113
p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)
114
if err != nil {
115
return notFound(err)
116
}
117
jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)
118
var running []int64
119
for _, j := range jobs {
120
if j.Status == "queued" || j.Status == "running" || j.Status == "manual" || j.Status == "pending" || j.Status == "created" {
121
ok, _ := s.Store.CancelJob(ctx, j.ID)
122
if ok && (j.Status == "running" || j.Status == "queued") {
123
running = append(running, j.ID)
124
}
125
}
126
}
127
if s.Runner != nil {
128
s.Runner.Interrupt(running)
129
}
130
_, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)
131
return nil
132
}
133
134
func (s *Server) opLintCI(r *http.Request, repo store.Repo, body, ref string) (map[string]any, error) {
135
if len(body) > ciMaxBytes {
136
return nil, fail(400, i18n.E("edit.fail"))
137
}
138
ref = safeRev(ref, repo.DefaultBranch)
139
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
140
model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))
141
lines := make([]string, len(model.Rows))
142
var bad []int
143
for i, row := range model.Rows {
144
lines[i] = string(row.HTML)
145
if row.Bad {
146
bad = append(bad, row.N)
147
}
148
}
149
return map[string]any{
150
"status": model.Status, "statusClass": model.Class, "errors": model.Errors,
151
"warnings": model.Warnings, "issues": model.Issues, "lines": lines, "bad": bad,
152
}, nil
153
}
154
155
func (s *Server) opSaveCI(ctx context.Context, user store.User, repo store.Repo, base, branch, message, body string, openMR bool) (string, int64, error) {
156
role, err := s.repoRole(ctx, user, repo)
157
if err != nil {
158
return "", 0, err
159
}
160
base = safeRev(base, repo.DefaultBranch)
161
if !validBranchName(branch) {
162
return "", 0, fail(400, i18n.E("edit.badBranch"))
163
}
164
if len(body) > ciMaxBytes {
165
return "", 0, fail(400, i18n.E("edit.fail"))
166
}
167
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
168
if openMR && (branch == base || access.BranchProtected(patterns, branch)) {
169
return "", 0, fail(400, i18n.E("edit.badBranch"))
170
}
171
sha, err := s.opWriteFiles(ctx, user, repo, role, branch, base, message, "", map[string]string{ciFile: body}, nil)
172
if err != nil {
173
return "", 0, err
174
}
175
if !openMR {
176
return sha, 0, nil
177
}
178
existing, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch)
179
if err != nil {
180
return sha, 0, fail(400, err)
181
}
182
if len(existing) > 0 {
183
return sha, existing[0].Number, nil
184
}
185
mr, err := s.opCreateMR(ctx, user, repo, message, "", branch, base, false)
186
if err != nil {
187
return sha, 0, err
188
}
189
return sha, mr.Number, nil
190
}
191
192
func (s *Server) opPublishRelease(ctx context.Context, repo store.Repo, author store.User, job store.Job, req releaseRequest) (int64, error) {
193
if s.StoragePath() == "" {
194
return 0, fail(503, i18n.E("err.noStorage"))
195
}
196
if err := names.ValidTag(req.Tag); err != nil {
197
return 0, fail(400, err)
198
}
199
if !safeSHA(req.Commit) {
200
return 0, fail(400, i18n.E("err.commitAbsent"))
201
}
202
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
203
if !gitrepo.HasCommit(ctx, s.Git, dir, req.Commit) {
204
return 0, fail(400, i18n.E("err.commitMissing"))
205
}
206
if req.Name == "" {
207
req.Name = req.Tag
208
}
209
if job.ID == 0 && len(req.Assets) > 0 {
210
return 0, fail(400, i18n.E("err.assetsJob"))
211
}
212
var assets []store.ReleaseAsset
213
for _, a := range req.Assets {
214
if a.Name == "" {
215
a.Name = filepath.Base(a.Path)
216
}
217
if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" {
218
return 0, fail(400, i18n.E("err.assetName"))
219
}
220
src, err := s.Store.ArtifactPath(ctx, job.PipelineID, a.Job, a.Path)
221
if err != nil {
222
return 0, fail(400, i18n.E("err.artifactMissing", a.Job, a.Path))
223
}
224
info, err := os.Stat(src)
225
if err != nil {
226
return 0, fail(400, i18n.E("err.assetDisk"))
227
}
228
dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name)
229
if err := copyRelease(src, dst); err != nil {
230
return 0, fail(500, i18n.E("err.assetCopy"))
231
}
232
assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: info.Size()})
233
}
234
if err := s.postReceive(ctx, repo, author, dir, func() error {
235
return gitrepo.Tag(ctx, s.Git, dir, req.Tag, req.Commit, req.Name)
236
}); err != nil {
237
return 0, fail(400, i18n.E("err.tagFail", err.Error()))
238
}
239
authorID := author.ID
240
id, err := s.Store.CreateRelease(ctx, repo.ID, req.Tag, req.Commit, req.Name, req.Body, authorID, job.ID, assets)
241
if err != nil {
242
return 0, fail(400, err)
243
}
244
s.Dispatch(repo.ID, webhook.Event{
245
Type: webhook.EventRelease, Project: repo.FullPath(), Commit: req.Commit,
246
ReleaseTag: req.Tag, Summary: i18n.T(i18n.EN, "hook.release", req.Tag, repo.FullPath()),
247
URL: strings.TrimRight(s.Cfg.BaseURL, "/") + repoURL(repo) + "/-/releases",
248
})
249
return id, nil
250
}
251
252
func (s *Server) opCIFile(ctx context.Context, repo store.Repo, ref string) (string, error) {
253
ref = safeRev(ref, repo.DefaultBranch)
254
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
255
body := gitOne(ctx, s.Git, dir, "show", ref+":"+ciFile)
256
return body, nil
257
}
@@ -0,0 +1,257 @@1
package server2
3
import (4
"context"5
"net/http"6
"os"7
"path/filepath"8
"strings"9
10
"gitlab.com/Timfa/bluegit/internal/access"11
"gitlab.com/Timfa/bluegit/internal/gitrepo"12
"gitlab.com/Timfa/bluegit/internal/i18n"13
"gitlab.com/Timfa/bluegit/internal/names"14
"gitlab.com/Timfa/bluegit/internal/store"15
"gitlab.com/Timfa/bluegit/internal/webhook"16
)17
18
func (s *Server) opRunPipeline(ctx context.Context, user store.User, repo store.Repo, ref, source string) (int64, error) {19
role, err := s.repoRole(ctx, user, repo)20
if err != nil {21
return 0, err22
}23
if !role.CanWriteCode() {24
return 0, fail(403, i18n.E("err.forbidden"))25
}26
ref = safeRev(ref, repo.DefaultBranch)27
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)28
sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", ref+"^{commit}")29
if sha == "" {30
return 0, fail(400, i18n.E("err.branchMissing"))31
}32
if source == "" {33
source = "api"34
}35
id := s.startPipeline(ctx, repo, sha, "refs/heads/"+ref, user.Username, source, "", nil)36
return id, nil37
}38
39
func (s *Server) opJobAction(ctx context.Context, user store.User, repo store.Repo, pipeID, jobID int64, action string) (store.Job, error) {40
role, err := s.repoRole(ctx, user, repo)41
if err != nil {42
return store.Job{}, err43
}44
if !role.CanWriteCode() {45
return store.Job{}, fail(403, i18n.E("err.forbidden"))46
}47
p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)48
if err != nil {49
return store.Job{}, notFound(err)50
}51
jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)52
var job store.Job53
found := false54
for _, j := range jobs {55
if j.ID == jobID {56
job = j57
found = true58
break59
}60
}61
if !found {62
return store.Job{}, fail(404, i18n.E("err.notFound"))63
}64
switch action {65
case "play":66
ok, err := s.Store.QueueJob(ctx, job.ID)67
if err != nil {68
return store.Job{}, fail(400, err)69
}70
if !ok {71
return store.Job{}, fail(409, i18n.E("err.jobState"))72
}73
case "retry":74
ok, err := s.Store.RetryJob(ctx, job.ID)75
if err != nil {76
return store.Job{}, fail(400, err)77
}78
if !ok {79
return store.Job{}, fail(409, i18n.E("err.jobState"))80
}81
case "cancel":82
ok, err := s.Store.CancelJob(ctx, job.ID)83
if err != nil {84
return store.Job{}, fail(400, err)85
}86
if !ok {87
return store.Job{}, fail(409, i18n.E("err.jobState"))88
}89
if s.Runner != nil {90
s.Runner.Interrupt([]int64{job.ID})91
}92
_, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)93
default:94
return store.Job{}, fail(400, i18n.E("err.jobState"))95
}96
jobs, _ = s.Store.JobsByPipeline(ctx, p.ID)97
for _, j := range jobs {98
if j.ID == jobID {99
return j, nil100
}101
}102
return job, nil103
}104
105
func (s *Server) opCancelPipeline(ctx context.Context, user store.User, repo store.Repo, pipeID int64) error {106
role, err := s.repoRole(ctx, user, repo)107
if err != nil {108
return err109
}110
if !role.CanWriteCode() {111
return fail(403, i18n.E("err.forbidden"))112
}113
p, err := s.Store.PipelineByID(ctx, repo.ID, pipeID)114
if err != nil {115
return notFound(err)116
}117
jobs, _ := s.Store.JobsByPipeline(ctx, p.ID)118
var running []int64119
for _, j := range jobs {120
if j.Status == "queued" || j.Status == "running" || j.Status == "manual" || j.Status == "pending" || j.Status == "created" {121
ok, _ := s.Store.CancelJob(ctx, j.ID)122
if ok && (j.Status == "running" || j.Status == "queued") {123
running = append(running, j.ID)124
}125
}126
}127
if s.Runner != nil {128
s.Runner.Interrupt(running)129
}130
_, _ = s.Store.RefreshPipelineStatus(ctx, p.ID)131
return nil132
}133
134
func (s *Server) opLintCI(r *http.Request, repo store.Repo, body, ref string) (map[string]any, error) {135
if len(body) > ciMaxBytes {136
return nil, fail(400, i18n.E("edit.fail"))137
}138
ref = safeRev(ref, repo.DefaultBranch)139
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)140
model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))141
lines := make([]string, len(model.Rows))142
var bad []int143
for i, row := range model.Rows {144
lines[i] = string(row.HTML)145
if row.Bad {146
bad = append(bad, row.N)147
}148
}149
return map[string]any{150
"status": model.Status, "statusClass": model.Class, "errors": model.Errors,151
"warnings": model.Warnings, "issues": model.Issues, "lines": lines, "bad": bad,152
}, nil153
}154
155
func (s *Server) opSaveCI(ctx context.Context, user store.User, repo store.Repo, base, branch, message, body string, openMR bool) (string, int64, error) {156
role, err := s.repoRole(ctx, user, repo)157
if err != nil {158
return "", 0, err159
}160
base = safeRev(base, repo.DefaultBranch)161
if !validBranchName(branch) {162
return "", 0, fail(400, i18n.E("edit.badBranch"))163
}164
if len(body) > ciMaxBytes {165
return "", 0, fail(400, i18n.E("edit.fail"))166
}167
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)168
if openMR && (branch == base || access.BranchProtected(patterns, branch)) {169
return "", 0, fail(400, i18n.E("edit.badBranch"))170
}171
sha, err := s.opWriteFiles(ctx, user, repo, role, branch, base, message, "", map[string]string{ciFile: body}, nil)172
if err != nil {173
return "", 0, err174
}175
if !openMR {176
return sha, 0, nil177
}178
existing, err := s.Store.OpenMergeRequestsBySource(ctx, repo.ID, branch)179
if err != nil {180
return sha, 0, fail(400, err)181
}182
if len(existing) > 0 {183
return sha, existing[0].Number, nil184
}185
mr, err := s.opCreateMR(ctx, user, repo, message, "", branch, base, false)186
if err != nil {187
return sha, 0, err188
}189
return sha, mr.Number, nil190
}191
192
func (s *Server) opPublishRelease(ctx context.Context, repo store.Repo, author store.User, job store.Job, req releaseRequest) (int64, error) {193
if s.StoragePath() == "" {194
return 0, fail(503, i18n.E("err.noStorage"))195
}196
if err := names.ValidTag(req.Tag); err != nil {197
return 0, fail(400, err)198
}199
if !safeSHA(req.Commit) {200
return 0, fail(400, i18n.E("err.commitAbsent"))201
}202
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)203
if !gitrepo.HasCommit(ctx, s.Git, dir, req.Commit) {204
return 0, fail(400, i18n.E("err.commitMissing"))205
}206
if req.Name == "" {207
req.Name = req.Tag208
}209
if job.ID == 0 && len(req.Assets) > 0 {210
return 0, fail(400, i18n.E("err.assetsJob"))211
}212
var assets []store.ReleaseAsset213
for _, a := range req.Assets {214
if a.Name == "" {215
a.Name = filepath.Base(a.Path)216
}217
if strings.Contains(a.Name, "/") || strings.Contains(a.Name, "..") || a.Path == "" {218
return 0, fail(400, i18n.E("err.assetName"))219
}220
src, err := s.Store.ArtifactPath(ctx, job.PipelineID, a.Job, a.Path)221
if err != nil {222
return 0, fail(400, i18n.E("err.artifactMissing", a.Job, a.Path))223
}224
info, err := os.Stat(src)225
if err != nil {226
return 0, fail(400, i18n.E("err.assetDisk"))227
}228
dst := filepath.Join(s.StoragePath(), "releases", repo.OwnerPath, repo.Name, req.Tag, a.Name)229
if err := copyRelease(src, dst); err != nil {230
return 0, fail(500, i18n.E("err.assetCopy"))231
}232
assets = append(assets, store.ReleaseAsset{Name: a.Name, StoragePath: dst, Size: info.Size()})233
}234
if err := s.postReceive(ctx, repo, author, dir, func() error {235
return gitrepo.Tag(ctx, s.Git, dir, req.Tag, req.Commit, req.Name)236
}); err != nil {237
return 0, fail(400, i18n.E("err.tagFail", err.Error()))238
}239
authorID := author.ID240
id, err := s.Store.CreateRelease(ctx, repo.ID, req.Tag, req.Commit, req.Name, req.Body, authorID, job.ID, assets)241
if err != nil {242
return 0, fail(400, err)243
}244
s.Dispatch(repo.ID, webhook.Event{245
Type: webhook.EventRelease, Project: repo.FullPath(), Commit: req.Commit,246
ReleaseTag: req.Tag, Summary: i18n.T(i18n.EN, "hook.release", req.Tag, repo.FullPath()),247
URL: strings.TrimRight(s.Cfg.BaseURL, "/") + repoURL(repo) + "/-/releases",248
})249
return id, nil250
}251
252
func (s *Server) opCIFile(ctx context.Context, repo store.Repo, ref string) (string, error) {253
ref = safeRev(ref, repo.DefaultBranch)254
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)255
body := gitOne(ctx, s.Git, dir, "show", ref+":"+ciFile)256
return body, nil257
}@@ -0,0 +1,357 @@
1
package server
2
3
import (
4
"context"
5
"os"
6
"strings"
7
8
"gitlab.com/Timfa/bluegit/internal/access"
9
"gitlab.com/Timfa/bluegit/internal/gitrepo"
10
"gitlab.com/Timfa/bluegit/internal/i18n"
11
"gitlab.com/Timfa/bluegit/internal/names"
12
"gitlab.com/Timfa/bluegit/internal/state"
13
"gitlab.com/Timfa/bluegit/internal/store"
14
"gitlab.com/Timfa/bluegit/internal/webhook"
15
)
16
17
func (s *Server) opCreateGroup(ctx context.Context, user store.User, display, description, defaultRole string) (store.Group, error) {
18
display = strings.TrimSpace(display)
19
path, err := slugKind("group", display)
20
if err != nil {
21
return store.Group{}, fail(400, err)
22
}
23
role := access.Role("")
24
if strings.TrimSpace(defaultRole) != "" {
25
role, err = access.ParseRole(defaultRole)
26
if err != nil {
27
return store.Group{}, fail(400, err)
28
}
29
}
30
g, err := s.Store.CreateGroup(ctx, user.ID, display, path, description, role)
31
if err != nil {
32
return store.Group{}, fail(400, err)
33
}
34
return g, nil
35
}
36
37
func slugKind(kind, raw string) (string, error) {
38
path, err := names.Slug(kind, raw)
39
if err != nil {
40
return "", i18n.E("slug.bad")
41
}
42
return path, nil
43
}
44
45
func (s *Server) opUpdateGroup(ctx context.Context, user store.User, g store.Group, description, visibility, defaultRole string) error {
46
role, err := s.Store.GroupRole(ctx, g.ID, user.ID)
47
if err != nil || !role.AtLeast(access.RoleMaintainer) {
48
return fail(403, i18n.E("err.forbidden"))
49
}
50
if visibility != "public" {
51
visibility = "private"
52
}
53
next := g.DefaultRole
54
if strings.TrimSpace(defaultRole) != "" {
55
next, err = access.ParseRole(defaultRole)
56
if err != nil {
57
return fail(400, err)
58
}
59
}
60
if err := s.Store.UpdateGroup(ctx, g.ID, description, visibility, next); err != nil {
61
return fail(400, err)
62
}
63
return nil
64
}
65
66
func (s *Server) opTransferGroup(ctx context.Context, user store.User, g store.Group, username, confirm string) error {
67
if user.ID != g.OwnerID {
68
return fail(403, i18n.E("err.ownerOnly"))
69
}
70
username = strings.ToLower(strings.TrimSpace(username))
71
if username == "" || confirm != username {
72
return fail(400, i18n.E("err.ownerConfirm"))
73
}
74
to, err := s.Store.UserByUsername(ctx, username)
75
if err != nil {
76
return fail(400, i18n.E("err.ownerMember"))
77
}
78
if err := s.Store.TransferGroupOwner(ctx, g.ID, user.ID, to.ID); err != nil {
79
return fail(400, err)
80
}
81
return nil
82
}
83
84
func (s *Server) opCreateRepo(ctx context.Context, user store.User, rawName, description, groupPath, visibility string, readme bool) (store.Repo, error) {
85
if s.StoragePath() == "" {
86
return store.Repo{}, fail(503, i18n.E("err.noStorage"))
87
}
88
name, err := slugKind("repo", rawName)
89
if err != nil {
90
return store.Repo{}, fail(400, err)
91
}
92
ownerKind := "user"
93
ownerID := user.ID
94
if gpath := strings.TrimSpace(groupPath); gpath != "" {
95
g, err := s.Store.GroupByPath(ctx, gpath)
96
if err != nil {
97
return store.Repo{}, fail(404, i18n.E("err.groupMissing"))
98
}
99
role, err := s.Store.GroupRole(ctx, g.ID, user.ID)
100
if err != nil || !role.CanManageSettings() {
101
return store.Repo{}, fail(403, i18n.E("err.forbidden"))
102
}
103
ownerKind, ownerID = "group", g.ID
104
}
105
if visibility != "public" {
106
visibility = "private"
107
}
108
repo, err := s.Store.CreateRepo(ctx, ownerKind, ownerID, name, description, s.Cfg.Git.DefaultBranch, visibility)
109
if err != nil {
110
return store.Repo{}, fail(400, err)
111
}
112
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
113
if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
114
_ = s.Store.DeleteRepo(ctx, repo.ID)
115
return store.Repo{}, fail(500, i18n.E("err.gitInit", err.Error()))
116
}
117
if readme {
118
role, _ := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
119
if _, err := s.opWriteFiles(ctx, user, repo, role, repo.DefaultBranch, "", "Initial commit", "", map[string]string{
120
"README.md": "# " + repo.Name + "\n",
121
}, nil); err != nil {
122
_ = s.Store.DeleteRepo(ctx, repo.ID)
123
_ = os.RemoveAll(dir)
124
return store.Repo{}, err
125
}
126
}
127
return repo, nil
128
}
129
130
func (s *Server) opUpdateRepo(ctx context.Context, user store.User, repo store.Repo, description, visibility string) error {
131
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
132
if err != nil || !role.CanManageSettings() {
133
return fail(403, i18n.E("err.forbidden"))
134
}
135
if visibility != "public" {
136
visibility = "private"
137
}
138
if err := s.Store.UpdateRepo(ctx, repo.ID, description, visibility); err != nil {
139
return fail(400, err)
140
}
141
return nil
142
}
143
144
func (s *Server) opDeleteRepo(ctx context.Context, user store.User, repo store.Repo, confirm string) error {
145
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
146
if err != nil || !role.CanManageSettings() {
147
return fail(403, i18n.E("err.forbidden"))
148
}
149
if confirm != repo.Name {
150
return fail(400, i18n.E("err.confirmDelete"))
151
}
152
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
153
if err := s.Store.DeleteRepo(ctx, repo.ID); err != nil {
154
return fail(400, err)
155
}
156
_ = os.RemoveAll(dir)
157
return nil
158
}
159
160
func (s *Server) manageScope(ctx context.Context, user store.User, kind string, id int64) error {
161
if kind == "group" {
162
role, err := s.Store.GroupRole(ctx, id, user.ID)
163
if err != nil || !role.AtLeast(access.RoleMaintainer) {
164
return fail(403, i18n.E("err.forbidden"))
165
}
166
return nil
167
}
168
role, err := s.Store.EffectiveRole(ctx, user.ID, id)
169
if err != nil || !role.CanManageSettings() {
170
return fail(403, i18n.E("err.forbidden"))
171
}
172
return nil
173
}
174
175
func (s *Server) opSetMember(ctx context.Context, user store.User, kind string, id int64, username, roleName string) error {
176
if err := s.manageScope(ctx, user, kind, id); err != nil {
177
return err
178
}
179
role, err := access.ParseRole(roleName)
180
if err != nil {
181
return fail(400, err)
182
}
183
if err := s.Store.SetMember(ctx, kind, id, username, role); err != nil {
184
return fail(400, err)
185
}
186
return nil
187
}
188
189
func (s *Server) opRemoveMember(ctx context.Context, user store.User, kind string, id int64, username string) error {
190
if err := s.manageScope(ctx, user, kind, id); err != nil {
191
return err
192
}
193
if err := s.Store.RemoveMember(ctx, kind, id, username); err != nil {
194
return fail(400, err)
195
}
196
return nil
197
}
198
199
func (s *Server) opPutSecret(ctx context.Context, user store.User, kind string, id int64, name, value string, protected bool) error {
200
if err := s.manageScope(ctx, user, kind, id); err != nil {
201
return err
202
}
203
if err := s.Store.PutSecret(ctx, kind, id, strings.TrimSpace(name), value, protected); err != nil {
204
return fail(400, err)
205
}
206
return nil
207
}
208
209
func (s *Server) opDeleteSecret(ctx context.Context, user store.User, kind string, id int64, name string) error {
210
if err := s.manageScope(ctx, user, kind, id); err != nil {
211
return err
212
}
213
_ = s.Store.DeleteSecret(ctx, kind, id, name)
214
return nil
215
}
216
217
type hookIn struct {
218
Name string
219
Preset string
220
Filter string
221
Events []string
222
Fields webhook.Input
223
}
224
225
func (s *Server) opCreateWebhook(ctx context.Context, user store.User, kind string, id int64, in hookIn) (int64, error) {
226
if err := s.manageScope(ctx, user, kind, id); err != nil {
227
return 0, err
228
}
229
if !webhook.KnownPreset(in.Preset) {
230
return 0, fail(400, i18n.E("err.preset"))
231
}
232
if _, err := webhook.MatchBranch(strings.TrimSpace(in.Filter), "main"); err != nil {
233
return 0, fail(400, err)
234
}
235
if len(in.Events) == 0 {
236
return 0, fail(400, i18n.E("err.pickEvent"))
237
}
238
spec, err := webhook.Prepare(in.Preset, in.Fields)
239
if err != nil {
240
return 0, fail(400, err)
241
}
242
wid, err := s.Store.CreateWebhook(ctx, store.Webhook{
243
ScopeKind: kind, ScopeID: id, Name: strings.TrimSpace(in.Name),
244
Preset: in.Preset, URLTemplate: spec.URL, Headers: spec.Headers,
245
BodyTemplate: spec.Body, Events: in.Events, BranchFilter: strings.TrimSpace(in.Filter), Method: spec.Method,
246
})
247
if err != nil {
248
return 0, fail(400, err)
249
}
250
return wid, nil
251
}
252
253
func (s *Server) opDeleteWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64) error {
254
if err := s.manageScope(ctx, user, kind, scopeID); err != nil {
255
return err
256
}
257
_ = s.Store.DeleteWebhook(ctx, kind, scopeID, id)
258
return nil
259
}
260
261
func (s *Server) opSaveRepoApproval(ctx context.Context, user store.User, repo store.Repo, pol store.ApprovalPolicy) error {
262
if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {
263
return err
264
}
265
_, groupPath, err := s.Store.EffectiveApproval(ctx, repo)
266
if err != nil {
267
return fail(400, err)
268
}
269
if groupPath != "" {
270
return fail(400, i18n.E("appr.locked"))
271
}
272
if err := s.Store.SaveApproval(ctx, "repo", repo.ID, pol); err != nil {
273
return fail(400, err)
274
}
275
return nil
276
}
277
278
func (s *Server) opSaveGroupApproval(ctx context.Context, user store.User, g store.Group, pol store.ApprovalPolicy) error {
279
if err := s.manageScope(ctx, user, "group", g.ID); err != nil {
280
return err
281
}
282
if err := s.Store.SaveApproval(ctx, "group", g.ID, pol); err != nil {
283
return fail(400, err)
284
}
285
return nil
286
}
287
288
func (s *Server) opProtect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error {
289
if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {
290
return err
291
}
292
var err error
293
if tag {
294
err = s.Store.AddProtectedTag(ctx, repo.ID, pattern)
295
} else {
296
err = s.Store.AddProtected(ctx, repo.ID, pattern)
297
}
298
if err != nil {
299
return fail(400, err)
300
}
301
return nil
302
}
303
304
func (s *Server) opUnprotect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error {
305
if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {
306
return err
307
}
308
if tag {
309
_ = s.Store.RemoveProtectedTag(ctx, repo.ID, pattern)
310
} else {
311
_ = s.Store.RemoveProtected(ctx, repo.ID, pattern)
312
}
313
return nil
314
}
315
316
func (s *Server) opToggleStar(ctx context.Context, user store.User, repo store.Repo) (bool, error) {
317
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
318
if err != nil {
319
return false, fail(500, err)
320
}
321
if user.ID == 0 || (!role.CanRead() && repo.Visibility != "public") {
322
return false, fail(403, i18n.E("err.forbidden"))
323
}
324
_, mine, err := s.Store.StarInfo(ctx, user.ID, []int64{repo.ID})
325
if err != nil {
326
return false, fail(400, err)
327
}
328
on := !mine[repo.ID]
329
if err := s.Store.SetStar(ctx, user.ID, repo.ID, on); err != nil {
330
return false, fail(400, err)
331
}
332
return on, nil
333
}
334
335
func (s *Server) opSetStorage(path string) (state.Info, bool, error) {
336
if s.StateDir == "" {
337
return state.Info{}, false, fail(500, i18n.E("err.storageSave"))
338
}
339
info, err := state.Inspect(path)
340
if err != nil {
341
return state.Info{}, false, fail(400, err)
342
}
343
same, err := samePath(s.StateDir, info.Path)
344
if err != nil {
345
return state.Info{}, false, fail(400, err)
346
}
347
if same {
348
return info, false, fail(400, i18n.E("err.storageSame"))
349
}
350
previous := s.StoragePath()
351
if err := state.Write(s.StateDir, info.Path); err != nil {
352
return state.Info{}, false, fail(500, err)
353
}
354
s.AdoptStorage(info.Path)
355
s.RefreshHooks()
356
return info, previous != "" && previous != info.Path, nil
357
}
@@ -0,0 +1,357 @@1
package server2
3
import (4
"context"5
"os"6
"strings"7
8
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/gitrepo"10
"gitlab.com/Timfa/bluegit/internal/i18n"11
"gitlab.com/Timfa/bluegit/internal/names"12
"gitlab.com/Timfa/bluegit/internal/state"13
"gitlab.com/Timfa/bluegit/internal/store"14
"gitlab.com/Timfa/bluegit/internal/webhook"15
)16
17
func (s *Server) opCreateGroup(ctx context.Context, user store.User, display, description, defaultRole string) (store.Group, error) {18
display = strings.TrimSpace(display)19
path, err := slugKind("group", display)20
if err != nil {21
return store.Group{}, fail(400, err)22
}23
role := access.Role("")24
if strings.TrimSpace(defaultRole) != "" {25
role, err = access.ParseRole(defaultRole)26
if err != nil {27
return store.Group{}, fail(400, err)28
}29
}30
g, err := s.Store.CreateGroup(ctx, user.ID, display, path, description, role)31
if err != nil {32
return store.Group{}, fail(400, err)33
}34
return g, nil35
}36
37
func slugKind(kind, raw string) (string, error) {38
path, err := names.Slug(kind, raw)39
if err != nil {40
return "", i18n.E("slug.bad")41
}42
return path, nil43
}44
45
func (s *Server) opUpdateGroup(ctx context.Context, user store.User, g store.Group, description, visibility, defaultRole string) error {46
role, err := s.Store.GroupRole(ctx, g.ID, user.ID)47
if err != nil || !role.AtLeast(access.RoleMaintainer) {48
return fail(403, i18n.E("err.forbidden"))49
}50
if visibility != "public" {51
visibility = "private"52
}53
next := g.DefaultRole54
if strings.TrimSpace(defaultRole) != "" {55
next, err = access.ParseRole(defaultRole)56
if err != nil {57
return fail(400, err)58
}59
}60
if err := s.Store.UpdateGroup(ctx, g.ID, description, visibility, next); err != nil {61
return fail(400, err)62
}63
return nil64
}65
66
func (s *Server) opTransferGroup(ctx context.Context, user store.User, g store.Group, username, confirm string) error {67
if user.ID != g.OwnerID {68
return fail(403, i18n.E("err.ownerOnly"))69
}70
username = strings.ToLower(strings.TrimSpace(username))71
if username == "" || confirm != username {72
return fail(400, i18n.E("err.ownerConfirm"))73
}74
to, err := s.Store.UserByUsername(ctx, username)75
if err != nil {76
return fail(400, i18n.E("err.ownerMember"))77
}78
if err := s.Store.TransferGroupOwner(ctx, g.ID, user.ID, to.ID); err != nil {79
return fail(400, err)80
}81
return nil82
}83
84
func (s *Server) opCreateRepo(ctx context.Context, user store.User, rawName, description, groupPath, visibility string, readme bool) (store.Repo, error) {85
if s.StoragePath() == "" {86
return store.Repo{}, fail(503, i18n.E("err.noStorage"))87
}88
name, err := slugKind("repo", rawName)89
if err != nil {90
return store.Repo{}, fail(400, err)91
}92
ownerKind := "user"93
ownerID := user.ID94
if gpath := strings.TrimSpace(groupPath); gpath != "" {95
g, err := s.Store.GroupByPath(ctx, gpath)96
if err != nil {97
return store.Repo{}, fail(404, i18n.E("err.groupMissing"))98
}99
role, err := s.Store.GroupRole(ctx, g.ID, user.ID)100
if err != nil || !role.CanManageSettings() {101
return store.Repo{}, fail(403, i18n.E("err.forbidden"))102
}103
ownerKind, ownerID = "group", g.ID104
}105
if visibility != "public" {106
visibility = "private"107
}108
repo, err := s.Store.CreateRepo(ctx, ownerKind, ownerID, name, description, s.Cfg.Git.DefaultBranch, visibility)109
if err != nil {110
return store.Repo{}, fail(400, err)111
}112
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)113
if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {114
_ = s.Store.DeleteRepo(ctx, repo.ID)115
return store.Repo{}, fail(500, i18n.E("err.gitInit", err.Error()))116
}117
if readme {118
role, _ := s.Store.EffectiveRole(ctx, user.ID, repo.ID)119
if _, err := s.opWriteFiles(ctx, user, repo, role, repo.DefaultBranch, "", "Initial commit", "", map[string]string{120
"README.md": "# " + repo.Name + "\n",121
}, nil); err != nil {122
_ = s.Store.DeleteRepo(ctx, repo.ID)123
_ = os.RemoveAll(dir)124
return store.Repo{}, err125
}126
}127
return repo, nil128
}129
130
func (s *Server) opUpdateRepo(ctx context.Context, user store.User, repo store.Repo, description, visibility string) error {131
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)132
if err != nil || !role.CanManageSettings() {133
return fail(403, i18n.E("err.forbidden"))134
}135
if visibility != "public" {136
visibility = "private"137
}138
if err := s.Store.UpdateRepo(ctx, repo.ID, description, visibility); err != nil {139
return fail(400, err)140
}141
return nil142
}143
144
func (s *Server) opDeleteRepo(ctx context.Context, user store.User, repo store.Repo, confirm string) error {145
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)146
if err != nil || !role.CanManageSettings() {147
return fail(403, i18n.E("err.forbidden"))148
}149
if confirm != repo.Name {150
return fail(400, i18n.E("err.confirmDelete"))151
}152
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)153
if err := s.Store.DeleteRepo(ctx, repo.ID); err != nil {154
return fail(400, err)155
}156
_ = os.RemoveAll(dir)157
return nil158
}159
160
func (s *Server) manageScope(ctx context.Context, user store.User, kind string, id int64) error {161
if kind == "group" {162
role, err := s.Store.GroupRole(ctx, id, user.ID)163
if err != nil || !role.AtLeast(access.RoleMaintainer) {164
return fail(403, i18n.E("err.forbidden"))165
}166
return nil167
}168
role, err := s.Store.EffectiveRole(ctx, user.ID, id)169
if err != nil || !role.CanManageSettings() {170
return fail(403, i18n.E("err.forbidden"))171
}172
return nil173
}174
175
func (s *Server) opSetMember(ctx context.Context, user store.User, kind string, id int64, username, roleName string) error {176
if err := s.manageScope(ctx, user, kind, id); err != nil {177
return err178
}179
role, err := access.ParseRole(roleName)180
if err != nil {181
return fail(400, err)182
}183
if err := s.Store.SetMember(ctx, kind, id, username, role); err != nil {184
return fail(400, err)185
}186
return nil187
}188
189
func (s *Server) opRemoveMember(ctx context.Context, user store.User, kind string, id int64, username string) error {190
if err := s.manageScope(ctx, user, kind, id); err != nil {191
return err192
}193
if err := s.Store.RemoveMember(ctx, kind, id, username); err != nil {194
return fail(400, err)195
}196
return nil197
}198
199
func (s *Server) opPutSecret(ctx context.Context, user store.User, kind string, id int64, name, value string, protected bool) error {200
if err := s.manageScope(ctx, user, kind, id); err != nil {201
return err202
}203
if err := s.Store.PutSecret(ctx, kind, id, strings.TrimSpace(name), value, protected); err != nil {204
return fail(400, err)205
}206
return nil207
}208
209
func (s *Server) opDeleteSecret(ctx context.Context, user store.User, kind string, id int64, name string) error {210
if err := s.manageScope(ctx, user, kind, id); err != nil {211
return err212
}213
_ = s.Store.DeleteSecret(ctx, kind, id, name)214
return nil215
}216
217
type hookIn struct {218
Name string219
Preset string220
Filter string221
Events []string222
Fields webhook.Input223
}224
225
func (s *Server) opCreateWebhook(ctx context.Context, user store.User, kind string, id int64, in hookIn) (int64, error) {226
if err := s.manageScope(ctx, user, kind, id); err != nil {227
return 0, err228
}229
if !webhook.KnownPreset(in.Preset) {230
return 0, fail(400, i18n.E("err.preset"))231
}232
if _, err := webhook.MatchBranch(strings.TrimSpace(in.Filter), "main"); err != nil {233
return 0, fail(400, err)234
}235
if len(in.Events) == 0 {236
return 0, fail(400, i18n.E("err.pickEvent"))237
}238
spec, err := webhook.Prepare(in.Preset, in.Fields)239
if err != nil {240
return 0, fail(400, err)241
}242
wid, err := s.Store.CreateWebhook(ctx, store.Webhook{243
ScopeKind: kind, ScopeID: id, Name: strings.TrimSpace(in.Name),244
Preset: in.Preset, URLTemplate: spec.URL, Headers: spec.Headers,245
BodyTemplate: spec.Body, Events: in.Events, BranchFilter: strings.TrimSpace(in.Filter), Method: spec.Method,246
})247
if err != nil {248
return 0, fail(400, err)249
}250
return wid, nil251
}252
253
func (s *Server) opDeleteWebhook(ctx context.Context, user store.User, kind string, scopeID, id int64) error {254
if err := s.manageScope(ctx, user, kind, scopeID); err != nil {255
return err256
}257
_ = s.Store.DeleteWebhook(ctx, kind, scopeID, id)258
return nil259
}260
261
func (s *Server) opSaveRepoApproval(ctx context.Context, user store.User, repo store.Repo, pol store.ApprovalPolicy) error {262
if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {263
return err264
}265
_, groupPath, err := s.Store.EffectiveApproval(ctx, repo)266
if err != nil {267
return fail(400, err)268
}269
if groupPath != "" {270
return fail(400, i18n.E("appr.locked"))271
}272
if err := s.Store.SaveApproval(ctx, "repo", repo.ID, pol); err != nil {273
return fail(400, err)274
}275
return nil276
}277
278
func (s *Server) opSaveGroupApproval(ctx context.Context, user store.User, g store.Group, pol store.ApprovalPolicy) error {279
if err := s.manageScope(ctx, user, "group", g.ID); err != nil {280
return err281
}282
if err := s.Store.SaveApproval(ctx, "group", g.ID, pol); err != nil {283
return fail(400, err)284
}285
return nil286
}287
288
func (s *Server) opProtect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error {289
if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {290
return err291
}292
var err error293
if tag {294
err = s.Store.AddProtectedTag(ctx, repo.ID, pattern)295
} else {296
err = s.Store.AddProtected(ctx, repo.ID, pattern)297
}298
if err != nil {299
return fail(400, err)300
}301
return nil302
}303
304
func (s *Server) opUnprotect(ctx context.Context, user store.User, repo store.Repo, pattern string, tag bool) error {305
if err := s.manageScope(ctx, user, "repo", repo.ID); err != nil {306
return err307
}308
if tag {309
_ = s.Store.RemoveProtectedTag(ctx, repo.ID, pattern)310
} else {311
_ = s.Store.RemoveProtected(ctx, repo.ID, pattern)312
}313
return nil314
}315
316
func (s *Server) opToggleStar(ctx context.Context, user store.User, repo store.Repo) (bool, error) {317
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)318
if err != nil {319
return false, fail(500, err)320
}321
if user.ID == 0 || (!role.CanRead() && repo.Visibility != "public") {322
return false, fail(403, i18n.E("err.forbidden"))323
}324
_, mine, err := s.Store.StarInfo(ctx, user.ID, []int64{repo.ID})325
if err != nil {326
return false, fail(400, err)327
}328
on := !mine[repo.ID]329
if err := s.Store.SetStar(ctx, user.ID, repo.ID, on); err != nil {330
return false, fail(400, err)331
}332
return on, nil333
}334
335
func (s *Server) opSetStorage(path string) (state.Info, bool, error) {336
if s.StateDir == "" {337
return state.Info{}, false, fail(500, i18n.E("err.storageSave"))338
}339
info, err := state.Inspect(path)340
if err != nil {341
return state.Info{}, false, fail(400, err)342
}343
same, err := samePath(s.StateDir, info.Path)344
if err != nil {345
return state.Info{}, false, fail(400, err)346
}347
if same {348
return info, false, fail(400, i18n.E("err.storageSame"))349
}350
previous := s.StoragePath()351
if err := state.Write(s.StateDir, info.Path); err != nil {352
return state.Info{}, false, fail(500, err)353
}354
s.AdoptStorage(info.Path)355
s.RefreshHooks()356
return info, previous != "" && previous != info.Path, nil357
}@@ -0,0 +1,238 @@
1
package server
2
3
import (
4
"context"
5
"os"
6
"strings"
7
8
"gitlab.com/Timfa/bluegit/internal/access"
9
"gitlab.com/Timfa/bluegit/internal/gitrepo"
10
"gitlab.com/Timfa/bluegit/internal/i18n"
11
"gitlab.com/Timfa/bluegit/internal/names"
12
"gitlab.com/Timfa/bluegit/internal/store"
13
)
14
15
func (s *Server) repoRole(ctx context.Context, user store.User, repo store.Repo) (access.Role, error) {
16
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)
17
if err != nil {
18
return "", fail(500, err)
19
}
20
return role, nil
21
}
22
23
func (s *Server) opCreateBranch(ctx context.Context, user store.User, repo store.Repo, name, from string) error {
24
role, err := s.repoRole(ctx, user, repo)
25
if err != nil {
26
return err
27
}
28
if !role.CanWriteCode() {
29
return fail(403, i18n.E("err.forbidden"))
30
}
31
name = strings.TrimSpace(name)
32
if err := names.ValidBranch(name); err != nil {
33
return fail(400, err)
34
}
35
from = safeRev(from, repo.DefaultBranch)
36
if from == "" {
37
return fail(400, i18n.E("err.branches"))
38
}
39
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
40
if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != "" {
41
return fail(400, i18n.E("err.branchName", name))
42
}
43
if err := s.postReceive(ctx, repo, user, dir, func() error {
44
return gitrepo.CreateBranch(ctx, s.Git, dir, name, from)
45
}); err != nil {
46
return fail(400, err)
47
}
48
return nil
49
}
50
51
func (s *Server) branchLockError(ctx context.Context, repo store.Repo, name string) error {
52
if name == repo.DefaultBranch {
53
return i18n.E("err.branchLocked", name)
54
}
55
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
56
if access.BranchProtected(patterns, name) {
57
return i18n.E("err.branchLocked", name)
58
}
59
return nil
60
}
61
62
func (s *Server) opDeleteBranch(ctx context.Context, user store.User, repo store.Repo, name, confirm string) error {
63
role, err := s.repoRole(ctx, user, repo)
64
if err != nil {
65
return err
66
}
67
if !role.CanWriteCode() {
68
return fail(403, i18n.E("err.forbidden"))
69
}
70
name = strings.TrimSpace(name)
71
if confirm != name || name == "" {
72
return fail(400, i18n.E("err.branchConfirm"))
73
}
74
if err := s.branchLockError(ctx, repo, name); err != nil {
75
return fail(400, err)
76
}
77
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
78
if err := s.postReceive(ctx, repo, user, dir, func() error {
79
return gitrepo.DeleteBranch(ctx, s.Git, dir, name)
80
}); err != nil {
81
return fail(400, err)
82
}
83
return nil
84
}
85
86
func (s *Server) opRenameBranch(ctx context.Context, user store.User, repo store.Repo, name, newName, confirm string) error {
87
role, err := s.repoRole(ctx, user, repo)
88
if err != nil {
89
return err
90
}
91
if !role.CanWriteCode() {
92
return fail(403, i18n.E("err.forbidden"))
93
}
94
name = strings.TrimSpace(name)
95
newName = strings.TrimSpace(newName)
96
if confirm != name || name == "" {
97
return fail(400, i18n.E("err.branchConfirm"))
98
}
99
if err := names.ValidBranch(newName); err != nil {
100
return fail(400, err)
101
}
102
if err := s.branchLockError(ctx, repo, name); err != nil {
103
return fail(400, err)
104
}
105
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
106
if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+newName) != "" {
107
return fail(400, i18n.E("err.branchName", newName))
108
}
109
if err := s.postReceive(ctx, repo, user, dir, func() error {
110
if err := gitrepo.RenameBranch(ctx, s.Git, dir, name, newName); err != nil {
111
return err
112
}
113
return s.Store.RenameOpenMRBranches(ctx, repo.ID, name, newName)
114
}); err != nil {
115
return fail(400, err)
116
}
117
return nil
118
}
119
120
func (s *Server) opCreateTag(ctx context.Context, user store.User, repo store.Repo, name, target, message string) error {
121
role, err := s.repoRole(ctx, user, repo)
122
if err != nil {
123
return err
124
}
125
if !role.CanWriteCode() {
126
return fail(403, i18n.E("err.forbidden"))
127
}
128
name = strings.TrimSpace(name)
129
if err := names.ValidTag(name); err != nil {
130
return fail(400, err)
131
}
132
patterns, _ := s.Store.ProtectedTagPatterns(ctx, repo.ID)
133
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
134
return fail(403, i18n.E("err.tagProtected", name))
135
}
136
if strings.TrimSpace(target) == "" {
137
target = repo.DefaultBranch
138
}
139
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
140
if err := s.postReceive(ctx, repo, user, dir, func() error {
141
return gitrepo.CreateTag(ctx, s.Git, dir, name, target, message, user.Username, userEmail(user.Username))
142
}); err != nil {
143
return fail(400, err)
144
}
145
return nil
146
}
147
148
func (s *Server) opDeleteTag(ctx context.Context, user store.User, repo store.Repo, name string) error {
149
role, err := s.repoRole(ctx, user, repo)
150
if err != nil {
151
return err
152
}
153
if !role.CanWriteCode() {
154
return fail(403, i18n.E("err.forbidden"))
155
}
156
name = strings.TrimSpace(name)
157
patterns, _ := s.Store.ProtectedTagPatterns(ctx, repo.ID)
158
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
159
return fail(403, i18n.E("err.tagProtected", name))
160
}
161
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
162
if err := gitrepo.DeleteTag(ctx, s.Git, dir, name); err != nil {
163
return fail(400, err)
164
}
165
return nil
166
}
167
168
type fileAction struct {
169
Action string `json:"action"`
170
Path string `json:"file_path"`
171
Content string `json:"content"`
172
}
173
174
func (s *Server) opWriteFiles(ctx context.Context, user store.User, repo store.Repo, role access.Role, branch, base, title, description string, files map[string]string, deletes []string) (string, error) {
175
if role == "" {
176
var err error
177
role, err = s.repoRole(ctx, user, repo)
178
if err != nil {
179
return "", err
180
}
181
}
182
if !role.CanWriteCode() {
183
return "", fail(403, i18n.E("err.forbidden"))
184
}
185
branch = strings.TrimSpace(branch)
186
if !validBranchName(branch) {
187
return "", fail(400, i18n.E("edit.badBranch"))
188
}
189
title = strings.TrimSpace(title)
190
if title == "" || strings.ContainsAny(title, "\r\n") {
191
return "", fail(400, i18n.E("edit.needMessage"))
192
}
193
if base == "" {
194
base = repo.DefaultBranch
195
}
196
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
197
if access.BranchProtected(patterns, branch) && !role.CanPushBranch(true) {
198
return "", fail(403, i18n.E("edit.protected"))
199
}
200
if s.StoragePath() == "" {
201
return "", fail(503, i18n.E("err.noStorage"))
202
}
203
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
204
work, err := s.scratchDir("api-commit")
205
if err != nil {
206
return "", fail(500, err)
207
}
208
defer os.RemoveAll(work)
209
if err := s.ensureBranch(ctx, dir, branch, base, work); err != nil {
210
return "", fail(400, err)
211
}
212
if err := s.postReceive(ctx, repo, user, dir, func() error {
213
return gitrepo.CommitChanges(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, files, deletes, role, patterns)
214
}); err != nil {
215
return "", fail(400, err)
216
}
217
return gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+branch), nil
218
}
219
220
func (s *Server) opCommitActions(ctx context.Context, user store.User, repo store.Repo, branch, base, title, description string, actions []fileAction) (string, error) {
221
files := map[string]string{}
222
var deletes []string
223
for _, a := range actions {
224
path, ok := repoPath(a.Path)
225
if !ok || path == "" {
226
return "", fail(400, i18n.E("err.sugFile"))
227
}
228
switch a.Action {
229
case "", "create", "update":
230
files[path] = a.Content
231
case "delete":
232
deletes = append(deletes, path)
233
default:
234
return "", fail(400, i18n.E("err.sugFile"))
235
}
236
}
237
return s.opWriteFiles(ctx, user, repo, "", branch, base, title, description, files, deletes)
238
}
@@ -0,0 +1,238 @@1
package server2
3
import (4
"context"5
"os"6
"strings"7
8
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/gitrepo"10
"gitlab.com/Timfa/bluegit/internal/i18n"11
"gitlab.com/Timfa/bluegit/internal/names"12
"gitlab.com/Timfa/bluegit/internal/store"13
)14
15
func (s *Server) repoRole(ctx context.Context, user store.User, repo store.Repo) (access.Role, error) {16
role, err := s.Store.EffectiveRole(ctx, user.ID, repo.ID)17
if err != nil {18
return "", fail(500, err)19
}20
return role, nil21
}22
23
func (s *Server) opCreateBranch(ctx context.Context, user store.User, repo store.Repo, name, from string) error {24
role, err := s.repoRole(ctx, user, repo)25
if err != nil {26
return err27
}28
if !role.CanWriteCode() {29
return fail(403, i18n.E("err.forbidden"))30
}31
name = strings.TrimSpace(name)32
if err := names.ValidBranch(name); err != nil {33
return fail(400, err)34
}35
from = safeRev(from, repo.DefaultBranch)36
if from == "" {37
return fail(400, i18n.E("err.branches"))38
}39
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)40
if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != "" {41
return fail(400, i18n.E("err.branchName", name))42
}43
if err := s.postReceive(ctx, repo, user, dir, func() error {44
return gitrepo.CreateBranch(ctx, s.Git, dir, name, from)45
}); err != nil {46
return fail(400, err)47
}48
return nil49
}50
51
func (s *Server) branchLockError(ctx context.Context, repo store.Repo, name string) error {52
if name == repo.DefaultBranch {53
return i18n.E("err.branchLocked", name)54
}55
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)56
if access.BranchProtected(patterns, name) {57
return i18n.E("err.branchLocked", name)58
}59
return nil60
}61
62
func (s *Server) opDeleteBranch(ctx context.Context, user store.User, repo store.Repo, name, confirm string) error {63
role, err := s.repoRole(ctx, user, repo)64
if err != nil {65
return err66
}67
if !role.CanWriteCode() {68
return fail(403, i18n.E("err.forbidden"))69
}70
name = strings.TrimSpace(name)71
if confirm != name || name == "" {72
return fail(400, i18n.E("err.branchConfirm"))73
}74
if err := s.branchLockError(ctx, repo, name); err != nil {75
return fail(400, err)76
}77
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)78
if err := s.postReceive(ctx, repo, user, dir, func() error {79
return gitrepo.DeleteBranch(ctx, s.Git, dir, name)80
}); err != nil {81
return fail(400, err)82
}83
return nil84
}85
86
func (s *Server) opRenameBranch(ctx context.Context, user store.User, repo store.Repo, name, newName, confirm string) error {87
role, err := s.repoRole(ctx, user, repo)88
if err != nil {89
return err90
}91
if !role.CanWriteCode() {92
return fail(403, i18n.E("err.forbidden"))93
}94
name = strings.TrimSpace(name)95
newName = strings.TrimSpace(newName)96
if confirm != name || name == "" {97
return fail(400, i18n.E("err.branchConfirm"))98
}99
if err := names.ValidBranch(newName); err != nil {100
return fail(400, err)101
}102
if err := s.branchLockError(ctx, repo, name); err != nil {103
return fail(400, err)104
}105
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)106
if gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+newName) != "" {107
return fail(400, i18n.E("err.branchName", newName))108
}109
if err := s.postReceive(ctx, repo, user, dir, func() error {110
if err := gitrepo.RenameBranch(ctx, s.Git, dir, name, newName); err != nil {111
return err112
}113
return s.Store.RenameOpenMRBranches(ctx, repo.ID, name, newName)114
}); err != nil {115
return fail(400, err)116
}117
return nil118
}119
120
func (s *Server) opCreateTag(ctx context.Context, user store.User, repo store.Repo, name, target, message string) error {121
role, err := s.repoRole(ctx, user, repo)122
if err != nil {123
return err124
}125
if !role.CanWriteCode() {126
return fail(403, i18n.E("err.forbidden"))127
}128
name = strings.TrimSpace(name)129
if err := names.ValidTag(name); err != nil {130
return fail(400, err)131
}132
patterns, _ := s.Store.ProtectedTagPatterns(ctx, repo.ID)133
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {134
return fail(403, i18n.E("err.tagProtected", name))135
}136
if strings.TrimSpace(target) == "" {137
target = repo.DefaultBranch138
}139
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)140
if err := s.postReceive(ctx, repo, user, dir, func() error {141
return gitrepo.CreateTag(ctx, s.Git, dir, name, target, message, user.Username, userEmail(user.Username))142
}); err != nil {143
return fail(400, err)144
}145
return nil146
}147
148
func (s *Server) opDeleteTag(ctx context.Context, user store.User, repo store.Repo, name string) error {149
role, err := s.repoRole(ctx, user, repo)150
if err != nil {151
return err152
}153
if !role.CanWriteCode() {154
return fail(403, i18n.E("err.forbidden"))155
}156
name = strings.TrimSpace(name)157
patterns, _ := s.Store.ProtectedTagPatterns(ctx, repo.ID)158
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {159
return fail(403, i18n.E("err.tagProtected", name))160
}161
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)162
if err := gitrepo.DeleteTag(ctx, s.Git, dir, name); err != nil {163
return fail(400, err)164
}165
return nil166
}167
168
type fileAction struct {169
Action string `json:"action"`170
Path string `json:"file_path"`171
Content string `json:"content"`172
}173
174
func (s *Server) opWriteFiles(ctx context.Context, user store.User, repo store.Repo, role access.Role, branch, base, title, description string, files map[string]string, deletes []string) (string, error) {175
if role == "" {176
var err error177
role, err = s.repoRole(ctx, user, repo)178
if err != nil {179
return "", err180
}181
}182
if !role.CanWriteCode() {183
return "", fail(403, i18n.E("err.forbidden"))184
}185
branch = strings.TrimSpace(branch)186
if !validBranchName(branch) {187
return "", fail(400, i18n.E("edit.badBranch"))188
}189
title = strings.TrimSpace(title)190
if title == "" || strings.ContainsAny(title, "\r\n") {191
return "", fail(400, i18n.E("edit.needMessage"))192
}193
if base == "" {194
base = repo.DefaultBranch195
}196
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)197
if access.BranchProtected(patterns, branch) && !role.CanPushBranch(true) {198
return "", fail(403, i18n.E("edit.protected"))199
}200
if s.StoragePath() == "" {201
return "", fail(503, i18n.E("err.noStorage"))202
}203
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)204
work, err := s.scratchDir("api-commit")205
if err != nil {206
return "", fail(500, err)207
}208
defer os.RemoveAll(work)209
if err := s.ensureBranch(ctx, dir, branch, base, work); err != nil {210
return "", fail(400, err)211
}212
if err := s.postReceive(ctx, repo, user, dir, func() error {213
return gitrepo.CommitChanges(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, files, deletes, role, patterns)214
}); err != nil {215
return "", fail(400, err)216
}217
return gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+branch), nil218
}219
220
func (s *Server) opCommitActions(ctx context.Context, user store.User, repo store.Repo, branch, base, title, description string, actions []fileAction) (string, error) {221
files := map[string]string{}222
var deletes []string223
for _, a := range actions {224
path, ok := repoPath(a.Path)225
if !ok || path == "" {226
return "", fail(400, i18n.E("err.sugFile"))227
}228
switch a.Action {229
case "", "create", "update":230
files[path] = a.Content231
case "delete":232
deletes = append(deletes, path)233
default:234
return "", fail(400, i18n.E("err.sugFile"))235
}236
}237
return s.opWriteFiles(ctx, user, repo, "", branch, base, title, description, files, deletes)238
}@@ -0,0 +1,314 @@
1
package server
2
3
import (
4
"context"
5
"net/http"
6
"os"
7
"strconv"
8
"strings"
9
10
"gitlab.com/Timfa/bluegit/internal/access"
11
"gitlab.com/Timfa/bluegit/internal/gitrepo"
12
"gitlab.com/Timfa/bluegit/internal/i18n"
13
"gitlab.com/Timfa/bluegit/internal/store"
14
)
15
16
func (s *Server) opCreateMR(ctx context.Context, user store.User, repo store.Repo, title, description, source, target string, draft bool) (store.MergeRequest, error) {
17
role, err := s.repoRole(ctx, user, repo)
18
if err != nil {
19
return store.MergeRequest{}, err
20
}
21
if !role.CanWriteCode() {
22
return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
23
}
24
source = safeRev(source, "")
25
target = safeRev(target, repo.DefaultBranch)
26
if source == "" || source == target {
27
return store.MergeRequest{}, fail(400, i18n.E("err.branches"))
28
}
29
mr, err := s.Store.CreateMergeRequest(ctx, repo.ID, user.ID, title, description, source, target)
30
if err != nil {
31
return store.MergeRequest{}, fail(400, err)
32
}
33
if draft {
34
_ = s.Store.SetDraft(ctx, mr.ID, true)
35
mr.Draft = true
36
}
37
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
38
if sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
39
s.startOneMergePipeline(ctx, repo, sha, user.Username, "", mr)
40
}
41
num := strconv.FormatInt(mr.Number, 10)
42
s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", user.Username, i18n.T(i18n.EN, "hook.mr", num, mr.Title), repoURL(repo)+"/-/merge-requests/"+num))
43
s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
44
return mr, nil
45
}
46
47
func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) {
48
role, err := s.repoRole(ctx, user, repo)
49
if err != nil {
50
return store.MergeRequest{}, err
51
}
52
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
53
if err != nil {
54
return store.MergeRequest{}, notFound(err)
55
}
56
if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) {
57
return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
58
}
59
title = strings.TrimSpace(title)
60
labels = normalizeLabels(labels)
61
if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil {
62
return store.MergeRequest{}, fail(400, err)
63
}
64
if title != mr.Title {
65
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title)
66
}
67
if labels != normalizeLabels(mr.Labels) {
68
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels)
69
}
70
mr.Title, mr.Description, mr.Labels = title, description, labels
71
return mr, nil
72
}
73
74
func (s *Server) opAddNote(r *http.Request, user store.User, repo store.Repo, number int64, body, path string, start, end int, parent int64) (store.Note, error) {
75
ctx := r.Context()
76
role, err := s.repoRole(ctx, user, repo)
77
if err != nil {
78
return store.Note{}, err
79
}
80
if !role.AtLeast(access.RoleReadonly) {
81
return store.Note{}, fail(403, i18n.E("err.forbidden"))
82
}
83
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
84
if err != nil {
85
return store.Note{}, notFound(err)
86
}
87
path, pathOK := repoPath(path)
88
if !pathOK {
89
return store.Note{}, fail(400, i18n.E("err.sugFile"))
90
}
91
if path == "" {
92
if parent > 0 {
93
note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body)
94
if err != nil {
95
return store.Note{}, fail(400, err)
96
}
97
return note, nil
98
}
99
note, err := s.Store.AddNote(ctx, repo.ID, mr.ID, user.ID, body)
100
if err != nil {
101
return store.Note{}, fail(400, err)
102
}
103
return note, nil
104
}
105
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
106
blob, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, path)
107
if err != nil {
108
return store.Note{}, fail(400, i18n.E("err.sugFile"))
109
}
110
lines := gitrepo.SplitLines(blob)
111
if start < 1 || end < start || end > len(lines) {
112
return store.Note{}, fail(400, i18n.E("err.sugLines"))
113
}
114
base := strings.Join(lines[start-1:end], "\n")
115
suggestion, _ := gitrepo.ParseSuggestion(body)
116
note, err := s.Store.AddLineNote(ctx, repo.ID, mr.ID, user.ID, body, path, start, end, suggestion, base)
117
if err != nil {
118
return store.Note{}, fail(400, err)
119
}
120
s.noteRequestsChanges(r, repo, mr, user.ID, suggestion)
121
return note, nil
122
}
123
124
func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error {
125
role, err := s.repoRole(ctx, user, repo)
126
if err != nil {
127
return err
128
}
129
if !role.CanWriteCode() {
130
return fail(403, i18n.E("err.forbidden"))
131
}
132
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
133
if err != nil || mr.Status != "open" {
134
return notFound(err)
135
}
136
switch status {
137
case "approved", "changes", "rejected":
138
default:
139
return fail(400, i18n.E("rev.bad"))
140
}
141
if status == "approved" {
142
if user.ID == mr.AuthorID {
143
return fail(400, i18n.E("rev.own"))
144
}
145
pol, _, err := s.Store.EffectiveApproval(ctx, repo)
146
if err != nil || !approvalCounts(role, pol) {
147
return fail(403, i18n.E("err.forbidden"))
148
}
149
}
150
if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil {
151
return fail(400, err)
152
}
153
return nil
154
}
155
156
func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error {
157
role, err := s.repoRole(ctx, user, repo)
158
if err != nil {
159
return err
160
}
161
if !role.CanManageSettings() {
162
return fail(403, i18n.E("err.forbidden"))
163
}
164
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
165
if err != nil {
166
return notFound(err)
167
}
168
if targetUser == 0 {
169
return fail(400, i18n.E("rev.bad"))
170
}
171
if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil {
172
return fail(400, err)
173
}
174
return nil
175
}
176
177
func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error {
178
role, err := s.repoRole(ctx, user, repo)
179
if err != nil {
180
return err
181
}
182
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
183
if err != nil || mr.Status != "open" {
184
return notFound(err)
185
}
186
patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID)
187
if err != nil {
188
return fail(400, err)
189
}
190
if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {
191
return fail(403, i18n.E("err.sugBranch", mr.SourceBranch))
192
}
193
title = strings.TrimSpace(title)
194
if title == "" || strings.ContainsAny(title, "\r\n") {
195
return fail(400, i18n.E("err.sugTitle"))
196
}
197
notes, err := s.Store.ListNotes(ctx, mr.ID)
198
if err != nil {
199
return fail(400, err)
200
}
201
byID := map[int64]store.Note{}
202
for _, n := range notes {
203
byID[n.ID] = n
204
}
205
var edits []gitrepo.SuggestionEdit
206
seen := map[int64]bool{}
207
for _, id := range ids {
208
if seen[id] {
209
continue
210
}
211
seen[id] = true
212
n, ok := byID[id]
213
if !ok || n.Suggestion == "" || n.FilePath == "" {
214
return fail(400, i18n.E("err.sugGone"))
215
}
216
edits = append(edits, gitrepo.SuggestionEdit{
217
Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion,
218
})
219
}
220
if len(edits) == 0 {
221
return fail(400, i18n.E("err.sugEmpty"))
222
}
223
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
224
files := map[string]string{}
225
for _, e := range edits {
226
if _, ok := files[e.Path]; ok {
227
continue
228
}
229
body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path)
230
if err != nil {
231
return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End))
232
}
233
files[e.Path] = body
234
}
235
updated, err := gitrepo.ApplySuggestions(files, edits)
236
if err != nil {
237
return fail(400, err)
238
}
239
branch := safeRev(mr.SourceBranch, "")
240
if branch == "" {
241
return fail(400, i18n.E("err.sugBranch", mr.SourceBranch))
242
}
243
work, err := s.scratchDir("suggest")
244
if err != nil {
245
return fail(500, err)
246
}
247
defer os.RemoveAll(work)
248
if err := s.postReceive(ctx, repo, user, dir, func() error {
249
return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns)
250
}); err != nil {
251
return fail(400, err)
252
}
253
return nil
254
}
255
256
func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64) error {
257
ctx := r.Context()
258
role, err := s.repoRole(ctx, user, repo)
259
if err != nil {
260
return err
261
}
262
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
263
if err != nil || mr.Status != "open" {
264
return notFound(err)
265
}
266
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
267
if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
268
return fail(403, i18n.E("err.targetAccess"))
269
}
270
if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {
271
return fail(409, i18n.E("err.mrBlocked", blocks[0]))
272
}
273
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
274
work, err := s.scratchDir("merge")
275
if err != nil {
276
return fail(500, err)
277
}
278
defer os.RemoveAll(work)
279
msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
280
if err := s.postReceive(ctx, repo, user, dir, func() error {
281
return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, role, patterns)
282
}); err != nil {
283
return fail(400, err)
284
}
285
_ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")
286
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "")
287
return nil
288
}
289
290
func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {
291
role, err := s.repoRole(ctx, user, repo)
292
if err != nil {
293
return err
294
}
295
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
296
if err != nil {
297
return notFound(err)
298
}
299
if user.ID != mr.AuthorID && !role.CanManageSettings() {
300
return fail(403, i18n.E("err.forbidden"))
301
}
302
want, kind := "closed", "closed"
303
if reopen {
304
if mr.Status != "closed" {
305
return notFound(nil)
306
}
307
want, kind = "open", "reopened"
308
}
309
if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {
310
return fail(400, err)
311
}
312
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")
313
return nil
314
}
@@ -0,0 +1,314 @@1
package server2
3
import (4
"context"5
"net/http"6
"os"7
"strconv"8
"strings"9
10
"gitlab.com/Timfa/bluegit/internal/access"11
"gitlab.com/Timfa/bluegit/internal/gitrepo"12
"gitlab.com/Timfa/bluegit/internal/i18n"13
"gitlab.com/Timfa/bluegit/internal/store"14
)15
16
func (s *Server) opCreateMR(ctx context.Context, user store.User, repo store.Repo, title, description, source, target string, draft bool) (store.MergeRequest, error) {17
role, err := s.repoRole(ctx, user, repo)18
if err != nil {19
return store.MergeRequest{}, err20
}21
if !role.CanWriteCode() {22
return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))23
}24
source = safeRev(source, "")25
target = safeRev(target, repo.DefaultBranch)26
if source == "" || source == target {27
return store.MergeRequest{}, fail(400, i18n.E("err.branches"))28
}29
mr, err := s.Store.CreateMergeRequest(ctx, repo.ID, user.ID, title, description, source, target)30
if err != nil {31
return store.MergeRequest{}, fail(400, err)32
}33
if draft {34
_ = s.Store.SetDraft(ctx, mr.ID, true)35
mr.Draft = true36
}37
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)38
if sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {39
s.startOneMergePipeline(ctx, repo, sha, user.Username, "", mr)40
}41
num := strconv.FormatInt(mr.Number, 10)42
s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", user.Username, i18n.T(i18n.EN, "hook.mr", num, mr.Title), repoURL(repo)+"/-/merge-requests/"+num))43
s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)44
return mr, nil45
}46
47
func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) {48
role, err := s.repoRole(ctx, user, repo)49
if err != nil {50
return store.MergeRequest{}, err51
}52
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)53
if err != nil {54
return store.MergeRequest{}, notFound(err)55
}56
if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) {57
return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))58
}59
title = strings.TrimSpace(title)60
labels = normalizeLabels(labels)61
if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil {62
return store.MergeRequest{}, fail(400, err)63
}64
if title != mr.Title {65
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title)66
}67
if labels != normalizeLabels(mr.Labels) {68
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels)69
}70
mr.Title, mr.Description, mr.Labels = title, description, labels71
return mr, nil72
}73
74
func (s *Server) opAddNote(r *http.Request, user store.User, repo store.Repo, number int64, body, path string, start, end int, parent int64) (store.Note, error) {75
ctx := r.Context()76
role, err := s.repoRole(ctx, user, repo)77
if err != nil {78
return store.Note{}, err79
}80
if !role.AtLeast(access.RoleReadonly) {81
return store.Note{}, fail(403, i18n.E("err.forbidden"))82
}83
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)84
if err != nil {85
return store.Note{}, notFound(err)86
}87
path, pathOK := repoPath(path)88
if !pathOK {89
return store.Note{}, fail(400, i18n.E("err.sugFile"))90
}91
if path == "" {92
if parent > 0 {93
note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body)94
if err != nil {95
return store.Note{}, fail(400, err)96
}97
return note, nil98
}99
note, err := s.Store.AddNote(ctx, repo.ID, mr.ID, user.ID, body)100
if err != nil {101
return store.Note{}, fail(400, err)102
}103
return note, nil104
}105
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)106
blob, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, path)107
if err != nil {108
return store.Note{}, fail(400, i18n.E("err.sugFile"))109
}110
lines := gitrepo.SplitLines(blob)111
if start < 1 || end < start || end > len(lines) {112
return store.Note{}, fail(400, i18n.E("err.sugLines"))113
}114
base := strings.Join(lines[start-1:end], "\n")115
suggestion, _ := gitrepo.ParseSuggestion(body)116
note, err := s.Store.AddLineNote(ctx, repo.ID, mr.ID, user.ID, body, path, start, end, suggestion, base)117
if err != nil {118
return store.Note{}, fail(400, err)119
}120
s.noteRequestsChanges(r, repo, mr, user.ID, suggestion)121
return note, nil122
}123
124
func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error {125
role, err := s.repoRole(ctx, user, repo)126
if err != nil {127
return err128
}129
if !role.CanWriteCode() {130
return fail(403, i18n.E("err.forbidden"))131
}132
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)133
if err != nil || mr.Status != "open" {134
return notFound(err)135
}136
switch status {137
case "approved", "changes", "rejected":138
default:139
return fail(400, i18n.E("rev.bad"))140
}141
if status == "approved" {142
if user.ID == mr.AuthorID {143
return fail(400, i18n.E("rev.own"))144
}145
pol, _, err := s.Store.EffectiveApproval(ctx, repo)146
if err != nil || !approvalCounts(role, pol) {147
return fail(403, i18n.E("err.forbidden"))148
}149
}150
if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil {151
return fail(400, err)152
}153
return nil154
}155
156
func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error {157
role, err := s.repoRole(ctx, user, repo)158
if err != nil {159
return err160
}161
if !role.CanManageSettings() {162
return fail(403, i18n.E("err.forbidden"))163
}164
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)165
if err != nil {166
return notFound(err)167
}168
if targetUser == 0 {169
return fail(400, i18n.E("rev.bad"))170
}171
if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil {172
return fail(400, err)173
}174
return nil175
}176
177
func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error {178
role, err := s.repoRole(ctx, user, repo)179
if err != nil {180
return err181
}182
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)183
if err != nil || mr.Status != "open" {184
return notFound(err)185
}186
patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID)187
if err != nil {188
return fail(400, err)189
}190
if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {191
return fail(403, i18n.E("err.sugBranch", mr.SourceBranch))192
}193
title = strings.TrimSpace(title)194
if title == "" || strings.ContainsAny(title, "\r\n") {195
return fail(400, i18n.E("err.sugTitle"))196
}197
notes, err := s.Store.ListNotes(ctx, mr.ID)198
if err != nil {199
return fail(400, err)200
}201
byID := map[int64]store.Note{}202
for _, n := range notes {203
byID[n.ID] = n204
}205
var edits []gitrepo.SuggestionEdit206
seen := map[int64]bool{}207
for _, id := range ids {208
if seen[id] {209
continue210
}211
seen[id] = true212
n, ok := byID[id]213
if !ok || n.Suggestion == "" || n.FilePath == "" {214
return fail(400, i18n.E("err.sugGone"))215
}216
edits = append(edits, gitrepo.SuggestionEdit{217
Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion,218
})219
}220
if len(edits) == 0 {221
return fail(400, i18n.E("err.sugEmpty"))222
}223
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)224
files := map[string]string{}225
for _, e := range edits {226
if _, ok := files[e.Path]; ok {227
continue228
}229
body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path)230
if err != nil {231
return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End))232
}233
files[e.Path] = body234
}235
updated, err := gitrepo.ApplySuggestions(files, edits)236
if err != nil {237
return fail(400, err)238
}239
branch := safeRev(mr.SourceBranch, "")240
if branch == "" {241
return fail(400, i18n.E("err.sugBranch", mr.SourceBranch))242
}243
work, err := s.scratchDir("suggest")244
if err != nil {245
return fail(500, err)246
}247
defer os.RemoveAll(work)248
if err := s.postReceive(ctx, repo, user, dir, func() error {249
return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns)250
}); err != nil {251
return fail(400, err)252
}253
return nil254
}255
256
func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64) error {257
ctx := r.Context()258
role, err := s.repoRole(ctx, user, repo)259
if err != nil {260
return err261
}262
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)263
if err != nil || mr.Status != "open" {264
return notFound(err)265
}266
patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)267
if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {268
return fail(403, i18n.E("err.targetAccess"))269
}270
if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {271
return fail(409, i18n.E("err.mrBlocked", blocks[0]))272
}273
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)274
work, err := s.scratchDir("merge")275
if err != nil {276
return fail(500, err)277
}278
defer os.RemoveAll(work)279
msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"280
if err := s.postReceive(ctx, repo, user, dir, func() error {281
return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, role, patterns)282
}); err != nil {283
return fail(400, err)284
}285
_ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")286
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "")287
return nil288
}289
290
func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {291
role, err := s.repoRole(ctx, user, repo)292
if err != nil {293
return err294
}295
mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)296
if err != nil {297
return notFound(err)298
}299
if user.ID != mr.AuthorID && !role.CanManageSettings() {300
return fail(403, i18n.E("err.forbidden"))301
}302
want, kind := "closed", "closed"303
if reopen {304
if mr.Status != "closed" {305
return notFound(nil)306
}307
want, kind = "open", "reopened"308
}309
if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {310
return fail(400, err)311
}312
_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")313
return nil314
}@@ -2,7 +2,6 @@ package server
2
2
3
3
import (
4
4
"net/http"
5
"strings"
6
5
7
6
"gitlab.com/Timfa/bluegit/internal/access"
8
7
"gitlab.com/Timfa/bluegit/internal/store"
@@ -15,22 +14,7 @@ func (s *Server) transferGroup(w http.ResponseWriter, r *http.Request) {
15
14
}
16
15
p := s.who(r)
17
16
back := "/groups/" + g.Path + "?tab=settings"
18
if !p.OK || p.User.ID != g.OwnerID {
19
http.Error(w, s.tr(r, "err.ownerOnly"), http.StatusForbidden)
20
return
21
}
22
username := strings.ToLower(strings.TrimSpace(r.FormValue("username")))
23
if username == "" || r.FormValue("confirm") != username {
24
s.redirect(w, r, back, "", s.tr(r, "err.ownerConfirm"))
25
return
26
}
27
to, err := s.Store.UserByUsername(r.Context(), username)
28
if err != nil {
29
s.redirect(w, r, back, "", s.tr(r, "err.ownerMember"))
30
return
31
}
32
if err := s.Store.TransferGroupOwner(r.Context(), g.ID, p.User.ID, to.ID); err != nil {
33
s.redirect(w, r, back, "", s.trErr(r, err))
17
if !s.uiOK(w, r, back, s.opTransferGroup(r.Context(), p.User, g, r.FormValue("username"), r.FormValue("confirm"))) {
34
18
return
35
19
}
36
20
s.redirect(w, r, back, s.tr(r, "flash.owner"), "")
@@ -2,7 +2,6 @@ package server2
2
3
import (3
import (4
"net/http"4
"net/http"5
"strings"6
5
7
"gitlab.com/Timfa/bluegit/internal/access"6
"gitlab.com/Timfa/bluegit/internal/access"8
"gitlab.com/Timfa/bluegit/internal/store"7
"gitlab.com/Timfa/bluegit/internal/store"@@ -15,22 +14,7 @@ func (s *Server) transferGroup(w http.ResponseWriter, r *http.Request) {15
}14
}16
p := s.who(r)15
p := s.who(r)17
back := "/groups/" + g.Path + "?tab=settings"16
back := "/groups/" + g.Path + "?tab=settings"18
if !p.OK || p.User.ID != g.OwnerID {17
if !s.uiOK(w, r, back, s.opTransferGroup(r.Context(), p.User, g, r.FormValue("username"), r.FormValue("confirm"))) {19
http.Error(w, s.tr(r, "err.ownerOnly"), http.StatusForbidden)20
return21
}22
username := strings.ToLower(strings.TrimSpace(r.FormValue("username")))23
if username == "" || r.FormValue("confirm") != username {24
s.redirect(w, r, back, "", s.tr(r, "err.ownerConfirm"))25
return26
}27
to, err := s.Store.UserByUsername(r.Context(), username)28
if err != nil {29
s.redirect(w, r, back, "", s.tr(r, "err.ownerMember"))30
return31
}32
if err := s.Store.TransferGroupOwner(r.Context(), g.ID, p.User.ID, to.ID); err != nil {33
s.redirect(w, r, back, "", s.trErr(r, err))34
return18
return35
}19
}36
s.redirect(w, r, back, s.tr(r, "flash.owner"), "")20
s.redirect(w, r, back, s.tr(r, "flash.owner"), "")@@ -401,7 +401,7 @@ func (s *Server) jobLog(w http.ResponseWriter, r *http.Request) {
401
401
}
402
402
403
403
func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {
404
_, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
404
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
405
405
if !ok || !s.csrfOK(w, r) {
406
406
return
407
407
}
@@ -409,7 +409,7 @@ func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {
409
409
if !ok {
410
410
return
411
411
}
412
_, _ = s.Store.QueueJob(r.Context(), job.ID)
412
_, _ = s.opJobAction(r.Context(), u, repo, p.ID, job.ID, "play")
413
413
s.redirect(w, r, repoURL(repo)+"/-/pipelines/"+strconv.FormatInt(p.ID, 10)+"/jobs/"+strconv.FormatInt(job.ID, 10), s.tr(r, "flash.pipeline"), "")
414
414
}
415
415
@@ -401,7 +401,7 @@ func (s *Server) jobLog(w http.ResponseWriter, r *http.Request) {401
}401
}402
402
403
func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {403
func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {404
_, repo, _, ok := s.guard(w, r, access.RoleDeveloper)404
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)405
if !ok || !s.csrfOK(w, r) {405
if !ok || !s.csrfOK(w, r) {406
return406
return407
}407
}@@ -409,7 +409,7 @@ func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {409
if !ok {409
if !ok {410
return410
return411
}411
}412
_, _ = s.Store.QueueJob(r.Context(), job.ID)412
_, _ = s.opJobAction(r.Context(), u, repo, p.ID, job.ID, "play")413
s.redirect(w, r, repoURL(repo)+"/-/pipelines/"+strconv.FormatInt(p.ID, 10)+"/jobs/"+strconv.FormatInt(job.ID, 10), s.tr(r, "flash.pipeline"), "")413
s.redirect(w, r, repoURL(repo)+"/-/pipelines/"+strconv.FormatInt(p.ID, 10)+"/jobs/"+strconv.FormatInt(job.ID, 10), s.tr(r, "flash.pipeline"), "")414
}414
}415
415
@@ -2,14 +2,12 @@ package server
2
2
3
3
import (
4
4
"net/http"
5
"os"
6
5
"strconv"
7
6
"strings"
8
7
9
8
"gitlab.com/Timfa/bluegit/internal/access"
10
9
"gitlab.com/Timfa/bluegit/internal/gitrepo"
11
10
"gitlab.com/Timfa/bluegit/internal/i18n"
12
"gitlab.com/Timfa/bluegit/internal/names"
13
11
"gitlab.com/Timfa/bluegit/internal/store"
14
12
)
15
13
@@ -178,35 +176,15 @@ func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {
178
176
}
179
177
180
178
func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
181
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
179
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
182
180
if !ok || !s.csrfOK(w, r) {
183
181
return
184
182
}
185
if !role.CanWriteCode() {
186
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
187
return
188
}
189
source := safeRev(r.FormValue("source"), "")
190
target := safeRev(r.FormValue("target"), repo.DefaultBranch)
191
if source == "" || source == target {
192
s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.tr(r, "err.branches"))
193
return
194
}
195
mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target)
196
if err != nil {
197
s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.trErr(r, err))
183
mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), r.FormValue("description"), r.FormValue("source"), r.FormValue("target"), r.FormValue("draft") == "1")
184
if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) {
198
185
return
199
186
}
200
187
num := strconv.FormatInt(mr.Number, 10)
201
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
202
if r.FormValue("draft") == "1" {
203
_ = s.Store.SetDraft(r.Context(), mr.ID, true)
204
}
205
if sha := gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
206
s.startOneMergePipeline(r.Context(), repo, sha, u.Username, "", mr)
207
}
208
s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, s.tr(r, "hook.mr", num, mr.Title), repoURL(repo)+"/-/merge-requests/"+num))
209
s.recordContribution(u.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
210
188
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")
211
189
}
212
190
@@ -246,119 +224,57 @@ func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {
246
224
}
247
225
248
226
func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
249
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
227
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
250
228
if !ok || !s.csrfOK(w, r) {
251
229
return
252
230
}
253
if u.ID == 0 || !role.AtLeast(access.RoleReadonly) {
254
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
255
return
256
}
257
mr, err := s.mrFromRequest(r, repo.ID)
231
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
258
232
if err != nil {
259
233
http.NotFound(w, r)
260
234
return
261
235
}
262
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
263
path, pathOK := repoPath(r.FormValue("path"))
264
if !pathOK {
265
s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))
266
return
267
}
268
if path == "" {
269
parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)
270
var noteErr error
271
if parent > 0 {
272
_, noteErr = s.Store.AddReply(r.Context(), repo.ID, mr.ID, u.ID, parent, r.FormValue("body"))
273
} else {
274
_, noteErr = s.Store.AddNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body"))
275
}
276
if noteErr != nil {
277
s.redirect(w, r, back, "", s.trErr(r, noteErr))
278
return
279
}
280
s.redirect(w, r, back, s.tr(r, "flash.note"), "")
281
return
282
}
236
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
237
parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)
283
238
start, _ := strconv.Atoi(r.FormValue("line_start"))
284
239
end, _ := strconv.Atoi(r.FormValue("line_end"))
285
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
286
blob, err := gitrepo.BlobText(r.Context(), s.Git, dir, mr.SourceBranch, path)
287
if err != nil {
288
s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))
289
return
290
}
291
lines := gitrepo.SplitLines(blob)
292
if start < 1 || end < start || end > len(lines) {
293
s.redirect(w, r, back, "", s.tr(r, "err.sugLines"))
240
if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) {
294
241
return
295
242
}
296
base := strings.Join(lines[start-1:end], "\n")
297
suggestion, _ := gitrepo.ParseSuggestion(r.FormValue("body"))
298
if _, err := s.Store.AddLineNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body"), path, start, end, suggestion, base); err != nil {
299
s.redirect(w, r, back, "", s.trErr(r, err))
300
return
301
}
302
s.noteRequestsChanges(r, repo, mr, u.ID, suggestion)
303
243
s.redirect(w, r, back, s.tr(r, "flash.note"), "")
304
244
}
305
245
306
246
func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
307
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
247
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
308
248
if !ok || !s.csrfOK(w, r) {
309
249
return
310
250
}
311
mr, err := s.mrFromRequest(r, repo.ID)
312
if err != nil || mr.Status != "open" {
313
http.NotFound(w, r)
314
return
315
}
316
patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
317
if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
318
http.Error(w, s.tr(r, "err.targetAccess"), http.StatusForbidden)
319
return
320
}
321
if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {
322
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", blocks[0])
323
return
324
}
325
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
326
work, err := s.scratchDir("merge")
251
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
327
252
if err != nil {
328
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", s.commitProblem(r, err))
253
http.NotFound(w, r)
329
254
return
330
255
}
331
defer os.RemoveAll(work)
332
email := u.Username + "@users.git.timfalken.com"
333
msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
334
if err := s.postReceive(r.Context(), repo, u, dir, func() error {
335
return gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns)
336
}); err != nil {
337
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", s.commitProblem(r, err))
256
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
257
if !s.uiOK(w, r, back, s.opMergeMR(r, u, repo, n)) {
338
258
return
339
259
}
340
_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged")
341
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "merged", "")
342
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.merged"), "")
260
s.redirect(w, r, back, s.tr(r, "flash.merged"), "")
343
261
}
344
262
345
263
func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
346
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
264
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
347
265
if !ok || !s.csrfOK(w, r) {
348
266
return
349
267
}
350
mr, err := s.mrFromRequest(r, repo.ID)
268
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
351
269
if err != nil {
352
270
http.NotFound(w, r)
353
271
return
354
272
}
355
if mr.AuthorID != u.ID && !role.CanManageSettings() {
356
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
273
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
274
if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) {
357
275
return
358
276
}
359
_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed")
360
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "closed", "")
361
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.closed"), "")
277
s.redirect(w, r, back, s.tr(r, "flash.closed"), "")
362
278
}
363
279
364
280
func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
@@ -431,14 +347,9 @@ func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {
431
347
if !ok || !s.csrfOK(w, r) {
432
348
return
433
349
}
434
ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
435
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
436
shaOut, err := gitSHA(r, s.Git, dir, ref)
437
if err != nil {
438
s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", s.tr(r, "err.branchMissing"))
350
if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) {
439
351
return
440
352
}
441
s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username, "web", "", nil)
442
353
s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")
443
354
}
444
355
@@ -459,50 +370,15 @@ func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {
459
370
if !ok || !s.csrfOK(w, r) {
460
371
return
461
372
}
462
if s.StoragePath() == "" {
463
msg := s.tr(r, "err.noStorage")
464
if wantsModal(r) {
465
writeModal(w, false, "", msg, http.StatusBadRequest)
466
return
467
}
468
s.redirect(w, r, "/", "", msg)
469
return
470
}
471
name, err := names.Slug("repo", r.FormValue("name"))
373
repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false)
472
374
if err != nil {
473
s.failCreate(w, r, s.tr(r, "slug.bad"))
474
return
475
}
476
ownerKind := "user"
477
ownerID := u.ID
478
if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {
479
g, err := s.Store.GroupByPath(r.Context(), gpath)
480
if err != nil {
481
s.failCreate(w, r, s.tr(r, "err.groupMissing"))
375
if statusOf(err) == http.StatusForbidden {
376
http.Error(w, s.trErr(r, err), http.StatusForbidden)
482
377
return
483
378
}
484
role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)
485
if err != nil || !role.CanManageSettings() {
486
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
487
return
488
}
489
ownerKind, ownerID = "group", g.ID
490
}
491
vis := r.FormValue("visibility")
492
if vis != "public" {
493
vis = "private"
494
}
495
repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)
496
if err != nil {
497
379
s.failCreate(w, r, s.trErr(r, err))
498
380
return
499
381
}
500
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
501
if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {
502
_ = s.Store.DeleteRepo(r.Context(), repo.ID)
503
s.failCreate(w, r, s.tr(r, "err.gitInit", err.Error()))
504
return
505
}
506
382
s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))
507
383
}
508
384
@@ -511,21 +387,7 @@ func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {
511
387
if !ok || !s.csrfOK(w, r) {
512
388
return
513
389
}
514
display := strings.TrimSpace(r.FormValue("name"))
515
path, err := names.Slug("group", display)
516
if err != nil {
517
s.failCreate(w, r, s.tr(r, "slug.bad"))
518
return
519
}
520
role := access.Role("")
521
if raw := strings.TrimSpace(r.FormValue("default_role")); raw != "" {
522
role, err = access.ParseRole(raw)
523
if err != nil {
524
s.failCreate(w, r, s.trErr(r, err))
525
return
526
}
527
}
528
g, err := s.Store.CreateGroup(r.Context(), u.ID, display, path, r.FormValue("description"), role)
390
g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role"))
529
391
if err != nil {
530
392
s.failCreate(w, r, s.trErr(r, err))
531
393
return
@@ -2,14 +2,12 @@ package server2
2
3
import (3
import (4
"net/http"4
"net/http"5
"os"6
"strconv"5
"strconv"7
"strings"6
"strings"8
7
9
"gitlab.com/Timfa/bluegit/internal/access"8
"gitlab.com/Timfa/bluegit/internal/access"10
"gitlab.com/Timfa/bluegit/internal/gitrepo"9
"gitlab.com/Timfa/bluegit/internal/gitrepo"11
"gitlab.com/Timfa/bluegit/internal/i18n"10
"gitlab.com/Timfa/bluegit/internal/i18n"12
"gitlab.com/Timfa/bluegit/internal/names"13
"gitlab.com/Timfa/bluegit/internal/store"11
"gitlab.com/Timfa/bluegit/internal/store"14
)12
)15
13
@@ -178,35 +176,15 @@ func (s *Server) mergeRequests(w http.ResponseWriter, r *http.Request) {178
}176
}179
177
180
func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {178
func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {181
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)179
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)182
if !ok || !s.csrfOK(w, r) {180
if !ok || !s.csrfOK(w, r) {183
return181
return184
}182
}185
if !role.CanWriteCode() {183
mr, err := s.opCreateMR(r.Context(), u, repo, r.FormValue("title"), r.FormValue("description"), r.FormValue("source"), r.FormValue("target"), r.FormValue("draft") == "1")186
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)184
if !s.uiOK(w, r, repoURL(repo)+"/-/merge-requests", err) {187
return188
}189
source := safeRev(r.FormValue("source"), "")190
target := safeRev(r.FormValue("target"), repo.DefaultBranch)191
if source == "" || source == target {192
s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.tr(r, "err.branches"))193
return194
}195
mr, err := s.Store.CreateMergeRequest(r.Context(), repo.ID, u.ID, r.FormValue("title"), r.FormValue("description"), source, target)196
if err != nil {197
s.redirect(w, r, repoURL(repo)+"/-/merge-requests", "", s.trErr(r, err))198
return185
return199
}186
}200
num := strconv.FormatInt(mr.Number, 10)187
num := strconv.FormatInt(mr.Number, 10)201
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)202
if r.FormValue("draft") == "1" {203
_ = s.Store.SetDraft(r.Context(), mr.ID, true)204
}205
if sha := gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {206
s.startOneMergePipeline(r.Context(), repo, sha, u.Username, "", mr)207
}208
s.Dispatch(repo.ID, pushEvent(repo, "merge_request", target, "", u.Username, s.tr(r, "hook.mr", num, mr.Title), repoURL(repo)+"/-/merge-requests/"+num))209
s.recordContribution(u.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)210
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")188
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+num, s.tr(r, "flash.mrOpened"), "")211
}189
}212
190
@@ -246,119 +224,57 @@ func (s *Server) showMR(w http.ResponseWriter, r *http.Request) {246
}224
}247
225
248
func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {226
func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {249
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)227
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)250
if !ok || !s.csrfOK(w, r) {228
if !ok || !s.csrfOK(w, r) {251
return229
return252
}230
}253
if u.ID == 0 || !role.AtLeast(access.RoleReadonly) {231
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)254
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)255
return256
}257
mr, err := s.mrFromRequest(r, repo.ID)258
if err != nil {232
if err != nil {259
http.NotFound(w, r)233
http.NotFound(w, r)260
return234
return261
}235
}262
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)236
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")263
path, pathOK := repoPath(r.FormValue("path"))237
parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)264
if !pathOK {265
s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))266
return267
}268
if path == "" {269
parent, _ := strconv.ParseInt(r.FormValue("parent"), 10, 64)270
var noteErr error271
if parent > 0 {272
_, noteErr = s.Store.AddReply(r.Context(), repo.ID, mr.ID, u.ID, parent, r.FormValue("body"))273
} else {274
_, noteErr = s.Store.AddNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body"))275
}276
if noteErr != nil {277
s.redirect(w, r, back, "", s.trErr(r, noteErr))278
return279
}280
s.redirect(w, r, back, s.tr(r, "flash.note"), "")281
return282
}283
start, _ := strconv.Atoi(r.FormValue("line_start"))238
start, _ := strconv.Atoi(r.FormValue("line_start"))284
end, _ := strconv.Atoi(r.FormValue("line_end"))239
end, _ := strconv.Atoi(r.FormValue("line_end"))285
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)240
if _, err := s.opAddNote(r, u, repo, n, r.FormValue("body"), r.FormValue("path"), start, end, parent); !s.uiOK(w, r, back, err) {286
blob, err := gitrepo.BlobText(r.Context(), s.Git, dir, mr.SourceBranch, path)287
if err != nil {288
s.redirect(w, r, back, "", s.tr(r, "err.sugFile"))289
return290
}291
lines := gitrepo.SplitLines(blob)292
if start < 1 || end < start || end > len(lines) {293
s.redirect(w, r, back, "", s.tr(r, "err.sugLines"))294
return241
return295
}242
}296
base := strings.Join(lines[start-1:end], "\n")297
suggestion, _ := gitrepo.ParseSuggestion(r.FormValue("body"))298
if _, err := s.Store.AddLineNote(r.Context(), repo.ID, mr.ID, u.ID, r.FormValue("body"), path, start, end, suggestion, base); err != nil {299
s.redirect(w, r, back, "", s.trErr(r, err))300
return301
}302
s.noteRequestsChanges(r, repo, mr, u.ID, suggestion)303
s.redirect(w, r, back, s.tr(r, "flash.note"), "")243
s.redirect(w, r, back, s.tr(r, "flash.note"), "")304
}244
}305
245
306
func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {246
func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {307
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)247
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)308
if !ok || !s.csrfOK(w, r) {248
if !ok || !s.csrfOK(w, r) {309
return249
return310
}250
}311
mr, err := s.mrFromRequest(r, repo.ID)251
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)312
if err != nil || mr.Status != "open" {313
http.NotFound(w, r)314
return315
}316
patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)317
if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {318
http.Error(w, s.tr(r, "err.targetAccess"), http.StatusForbidden)319
return320
}321
if blocks := s.mergeBlocks(r, repo, mr); len(blocks) > 0 {322
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", blocks[0])323
return324
}325
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)326
work, err := s.scratchDir("merge")327
if err != nil {252
if err != nil {328
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", s.commitProblem(r, err))253
http.NotFound(w, r)329
return254
return330
}255
}331
defer os.RemoveAll(work)256
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")332
email := u.Username + "@users.git.timfalken.com"257
if !s.uiOK(w, r, back, s.opMergeMR(r, u, repo, n)) {333
msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"334
if err := s.postReceive(r.Context(), repo, u, dir, func() error {335
return gitrepo.Merge(r.Context(), s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, u.Username, email, msg, role, patterns)336
}); err != nil {337
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), "", s.commitProblem(r, err))338
return258
return339
}259
}340
_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "merged")260
s.redirect(w, r, back, s.tr(r, "flash.merged"), "")341
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "merged", "")342
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.merged"), "")343
}261
}344
262
345
func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {263
func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {346
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)264
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)347
if !ok || !s.csrfOK(w, r) {265
if !ok || !s.csrfOK(w, r) {348
return266
return349
}267
}350
mr, err := s.mrFromRequest(r, repo.ID)268
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)351
if err != nil {269
if err != nil {352
http.NotFound(w, r)270
http.NotFound(w, r)353
return271
return354
}272
}355
if mr.AuthorID != u.ID && !role.CanManageSettings() {273
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")356
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)274
if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, false)) {357
return275
return358
}276
}359
_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "closed")277
s.redirect(w, r, back, s.tr(r, "flash.closed"), "")360
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "closed", "")361
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.closed"), "")362
}278
}363
279
364
func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {280
func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {@@ -431,14 +347,9 @@ func (s *Server) runPipeline(w http.ResponseWriter, r *http.Request) {431
if !ok || !s.csrfOK(w, r) {347
if !ok || !s.csrfOK(w, r) {432
return348
return433
}349
}434
ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)350
if _, err := s.opRunPipeline(r.Context(), u, repo, r.FormValue("ref"), "web"); !s.uiOK(w, r, repoURL(repo)+"/-/pipelines", err) {435
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)436
shaOut, err := gitSHA(r, s.Git, dir, ref)437
if err != nil {438
s.redirect(w, r, repoURL(repo)+"/-/pipelines", "", s.tr(r, "err.branchMissing"))439
return351
return440
}352
}441
s.startPipeline(r.Context(), repo, shaOut, "refs/heads/"+ref, u.Username, "web", "", nil)442
s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")353
s.redirect(w, r, repoURL(repo)+"/-/pipelines", s.tr(r, "flash.pipeline"), "")443
}354
}444
355
@@ -459,50 +370,15 @@ func (s *Server) createRepo(w http.ResponseWriter, r *http.Request) {459
if !ok || !s.csrfOK(w, r) {370
if !ok || !s.csrfOK(w, r) {460
return371
return461
}372
}462
if s.StoragePath() == "" {373
repo, err := s.opCreateRepo(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("group"), r.FormValue("visibility"), false)463
msg := s.tr(r, "err.noStorage")464
if wantsModal(r) {465
writeModal(w, false, "", msg, http.StatusBadRequest)466
return467
}468
s.redirect(w, r, "/", "", msg)469
return470
}471
name, err := names.Slug("repo", r.FormValue("name"))472
if err != nil {374
if err != nil {473
s.failCreate(w, r, s.tr(r, "slug.bad"))375
if statusOf(err) == http.StatusForbidden {474
return376
http.Error(w, s.trErr(r, err), http.StatusForbidden)475
}476
ownerKind := "user"477
ownerID := u.ID478
if gpath := strings.TrimSpace(r.FormValue("group")); gpath != "" {479
g, err := s.Store.GroupByPath(r.Context(), gpath)480
if err != nil {481
s.failCreate(w, r, s.tr(r, "err.groupMissing"))482
return377
return483
}378
}484
role, err := s.Store.GroupRole(r.Context(), g.ID, u.ID)485
if err != nil || !role.CanManageSettings() {486
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)487
return488
}489
ownerKind, ownerID = "group", g.ID490
}491
vis := r.FormValue("visibility")492
if vis != "public" {493
vis = "private"494
}495
repo, err := s.Store.CreateRepo(r.Context(), ownerKind, ownerID, name, r.FormValue("description"), s.Cfg.Git.DefaultBranch, vis)496
if err != nil {497
s.failCreate(w, r, s.trErr(r, err))379
s.failCreate(w, r, s.trErr(r, err))498
return380
return499
}381
}500
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)501
if err := gitrepo.Init(s.Git, dir, repo.DefaultBranch, s.HookBin); err != nil {502
_ = s.Store.DeleteRepo(r.Context(), repo.ID)503
s.failCreate(w, r, s.tr(r, "err.gitInit", err.Error()))504
return505
}506
s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))382
s.finishCreate(w, r, repoURL(repo), s.tr(r, "flash.repoCreated"))507
}383
}508
384
@@ -511,21 +387,7 @@ func (s *Server) createGroup(w http.ResponseWriter, r *http.Request) {511
if !ok || !s.csrfOK(w, r) {387
if !ok || !s.csrfOK(w, r) {512
return388
return513
}389
}514
display := strings.TrimSpace(r.FormValue("name"))390
g, err := s.opCreateGroup(r.Context(), u, r.FormValue("name"), r.FormValue("description"), r.FormValue("default_role"))515
path, err := names.Slug("group", display)516
if err != nil {517
s.failCreate(w, r, s.tr(r, "slug.bad"))518
return519
}520
role := access.Role("")521
if raw := strings.TrimSpace(r.FormValue("default_role")); raw != "" {522
role, err = access.ParseRole(raw)523
if err != nil {524
s.failCreate(w, r, s.trErr(r, err))525
return526
}527
}528
g, err := s.Store.CreateGroup(r.Context(), u.ID, display, path, r.FormValue("description"), role)529
if err != nil {391
if err != nil {530
s.failCreate(w, r, s.trErr(r, err))392
s.failCreate(w, r, s.trErr(r, err))531
return393
return@@ -87,16 +87,7 @@ func (s *Server) saveRepoApproval(w http.ResponseWriter, r *http.Request) {
87
87
if !ok || !s.csrfOK(w, r) {
88
88
return
89
89
}
90
_, groupPath, err := s.Store.EffectiveApproval(r.Context(), repo)
91
if err != nil {
92
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))
93
return
94
}
95
if groupPath != "" {
96
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.tr(r, "appr.locked"))
97
return
98
}
99
if err := s.Store.SaveApproval(r.Context(), "repo", repo.ID, approvalFromForm(r)); err != nil {
90
if err := s.opSaveRepoApproval(r.Context(), s.who(r).User, repo, approvalFromForm(r)); err != nil {
100
91
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))
101
92
return
102
93
}
@@ -108,7 +99,7 @@ func (s *Server) saveGroupApproval(w http.ResponseWriter, r *http.Request) {
108
99
if !ok || !s.csrfOK(w, r) {
109
100
return
110
101
}
111
if err := s.Store.SaveApproval(r.Context(), "group", g.ID, approvalFromForm(r)); err != nil {
102
if err := s.opSaveGroupApproval(r.Context(), s.who(r).User, g, approvalFromForm(r)); err != nil {
112
103
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))
113
104
return
114
105
}
@@ -204,89 +195,55 @@ func (s *Server) fillReviews(r *http.Request, v *View, repo store.Repo, mr store
204
195
}
205
196
206
197
func (s *Server) postReview(w http.ResponseWriter, r *http.Request) {
207
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
198
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
208
199
if !ok || !s.csrfOK(w, r) {
209
200
return
210
201
}
211
mr, err := s.mrFromRequest(r, repo.ID)
212
if err != nil || mr.Status != "open" {
202
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
203
if err != nil {
213
204
http.NotFound(w, r)
214
205
return
215
206
}
216
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
217
if !role.CanWriteCode() {
218
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
219
return
220
}
221
status := r.FormValue("status")
222
switch status {
223
case "approved", "changes", "rejected":
224
default:
225
s.redirect(w, r, back, "", s.tr(r, "rev.bad"))
226
return
227
}
228
if status == "approved" {
229
if u.ID == mr.AuthorID {
230
s.redirect(w, r, back, "", s.tr(r, "rev.own"))
231
return
232
}
233
pol, _, err := s.Store.EffectiveApproval(r.Context(), repo)
234
if err != nil || !approvalCounts(role, pol) {
235
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
236
return
237
}
238
}
239
if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, u.ID, status); err != nil {
240
s.redirect(w, r, back, "", s.trErr(r, err))
207
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
208
if !s.uiOK(w, r, back, s.opReview(r.Context(), u, repo, n, r.FormValue("status"))) {
241
209
return
242
210
}
243
211
s.redirect(w, r, back, s.tr(r, "flash.saved"), "")
244
212
}
245
213
246
214
func (s *Server) dismissReview(w http.ResponseWriter, r *http.Request) {
247
_, repo, role, ok := s.guard(w, r, access.RoleMaintainer)
215
u, repo, _, ok := s.guard(w, r, access.RoleMaintainer)
248
216
if !ok || !s.csrfOK(w, r) {
249
217
return
250
218
}
251
mr, err := s.mrFromRequest(r, repo.ID)
219
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
252
220
if err != nil {
253
221
http.NotFound(w, r)
254
222
return
255
223
}
256
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
257
if !role.CanManageSettings() {
258
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
259
return
260
}
224
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
261
225
userID, _ := strconv.ParseInt(r.FormValue("user_id"), 10, 64)
262
if userID == 0 {
263
s.redirect(w, r, back, "", s.tr(r, "rev.bad"))
264
return
265
}
266
if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, userID, "dismissed"); err != nil {
267
s.redirect(w, r, back, "", s.trErr(r, err))
226
if !s.uiOK(w, r, back, s.opDismissReview(r.Context(), u, repo, n, userID)) {
268
227
return
269
228
}
270
229
s.redirect(w, r, back, s.tr(r, "flash.saved"), "")
271
230
}
272
231
273
232
func (s *Server) reopenMR(w http.ResponseWriter, r *http.Request) {
274
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
233
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)
275
234
if !ok || !s.csrfOK(w, r) {
276
235
return
277
236
}
278
mr, err := s.mrFromRequest(r, repo.ID)
279
if err != nil || mr.Status != "closed" {
237
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
238
if err != nil {
280
239
http.NotFound(w, r)
281
240
return
282
241
}
283
if u.ID != mr.AuthorID && !role.CanManageSettings() {
284
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
242
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
243
if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, true)) {
285
244
return
286
245
}
287
_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "open")
288
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "reopened", "")
289
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.reopened"), "")
246
s.redirect(w, r, back, s.tr(r, "flash.reopened"), "")
290
247
}
291
248
292
249
// noteRequestsChanges zet Request changes als de reactie een suggestie bevat.
@@ -87,16 +87,7 @@ func (s *Server) saveRepoApproval(w http.ResponseWriter, r *http.Request) {87
if !ok || !s.csrfOK(w, r) {87
if !ok || !s.csrfOK(w, r) {88
return88
return89
}89
}90
_, groupPath, err := s.Store.EffectiveApproval(r.Context(), repo)90
if err := s.opSaveRepoApproval(r.Context(), s.who(r).User, repo, approvalFromForm(r)); err != nil {91
if err != nil {92
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))93
return94
}95
if groupPath != "" {96
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.tr(r, "appr.locked"))97
return98
}99
if err := s.Store.SaveApproval(r.Context(), "repo", repo.ID, approvalFromForm(r)); err != nil {100
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))91
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=approvals", "", s.trErr(r, err))101
return92
return102
}93
}@@ -108,7 +99,7 @@ func (s *Server) saveGroupApproval(w http.ResponseWriter, r *http.Request) {108
if !ok || !s.csrfOK(w, r) {99
if !ok || !s.csrfOK(w, r) {109
return100
return110
}101
}111
if err := s.Store.SaveApproval(r.Context(), "group", g.ID, approvalFromForm(r)); err != nil {102
if err := s.opSaveGroupApproval(r.Context(), s.who(r).User, g, approvalFromForm(r)); err != nil {112
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))103
s.redirect(w, r, "/groups/"+g.Path+"?tab=settings", "", s.trErr(r, err))113
return104
return114
}105
}@@ -204,89 +195,55 @@ func (s *Server) fillReviews(r *http.Request, v *View, repo store.Repo, mr store204
}195
}205
196
206
func (s *Server) postReview(w http.ResponseWriter, r *http.Request) {197
func (s *Server) postReview(w http.ResponseWriter, r *http.Request) {207
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)198
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)208
if !ok || !s.csrfOK(w, r) {199
if !ok || !s.csrfOK(w, r) {209
return200
return210
}201
}211
mr, err := s.mrFromRequest(r, repo.ID)202
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)212
if err != nil || mr.Status != "open" {203
if err != nil {213
http.NotFound(w, r)204
http.NotFound(w, r)214
return205
return215
}206
}216
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)207
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")217
if !role.CanWriteCode() {208
if !s.uiOK(w, r, back, s.opReview(r.Context(), u, repo, n, r.FormValue("status"))) {218
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)219
return220
}221
status := r.FormValue("status")222
switch status {223
case "approved", "changes", "rejected":224
default:225
s.redirect(w, r, back, "", s.tr(r, "rev.bad"))226
return227
}228
if status == "approved" {229
if u.ID == mr.AuthorID {230
s.redirect(w, r, back, "", s.tr(r, "rev.own"))231
return232
}233
pol, _, err := s.Store.EffectiveApproval(r.Context(), repo)234
if err != nil || !approvalCounts(role, pol) {235
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)236
return237
}238
}239
if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, u.ID, status); err != nil {240
s.redirect(w, r, back, "", s.trErr(r, err))241
return209
return242
}210
}243
s.redirect(w, r, back, s.tr(r, "flash.saved"), "")211
s.redirect(w, r, back, s.tr(r, "flash.saved"), "")244
}212
}245
213
246
func (s *Server) dismissReview(w http.ResponseWriter, r *http.Request) {214
func (s *Server) dismissReview(w http.ResponseWriter, r *http.Request) {247
_, repo, role, ok := s.guard(w, r, access.RoleMaintainer)215
u, repo, _, ok := s.guard(w, r, access.RoleMaintainer)248
if !ok || !s.csrfOK(w, r) {216
if !ok || !s.csrfOK(w, r) {249
return217
return250
}218
}251
mr, err := s.mrFromRequest(r, repo.ID)219
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)252
if err != nil {220
if err != nil {253
http.NotFound(w, r)221
http.NotFound(w, r)254
return222
return255
}223
}256
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)224
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")257
if !role.CanManageSettings() {258
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)259
return260
}261
userID, _ := strconv.ParseInt(r.FormValue("user_id"), 10, 64)225
userID, _ := strconv.ParseInt(r.FormValue("user_id"), 10, 64)262
if userID == 0 {226
if !s.uiOK(w, r, back, s.opDismissReview(r.Context(), u, repo, n, userID)) {263
s.redirect(w, r, back, "", s.tr(r, "rev.bad"))264
return265
}266
if err := s.Store.UpsertReview(r.Context(), repo.ID, mr.ID, userID, "dismissed"); err != nil {267
s.redirect(w, r, back, "", s.trErr(r, err))268
return227
return269
}228
}270
s.redirect(w, r, back, s.tr(r, "flash.saved"), "")229
s.redirect(w, r, back, s.tr(r, "flash.saved"), "")271
}230
}272
231
273
func (s *Server) reopenMR(w http.ResponseWriter, r *http.Request) {232
func (s *Server) reopenMR(w http.ResponseWriter, r *http.Request) {274
u, repo, role, ok := s.guard(w, r, access.RoleReadonly)233
u, repo, _, ok := s.guard(w, r, access.RoleReadonly)275
if !ok || !s.csrfOK(w, r) {234
if !ok || !s.csrfOK(w, r) {276
return235
return277
}236
}278
mr, err := s.mrFromRequest(r, repo.ID)237
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)279
if err != nil || mr.Status != "closed" {238
if err != nil {280
http.NotFound(w, r)239
http.NotFound(w, r)281
return240
return282
}241
}283
if u.ID != mr.AuthorID && !role.CanManageSettings() {242
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")284
http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)243
if !s.uiOK(w, r, back, s.opCloseMR(r.Context(), u, repo, n, true)) {285
return244
return286
}245
}287
_ = s.Store.SetMergeRequestStatus(r.Context(), mr.ID, "open")246
s.redirect(w, r, back, s.tr(r, "flash.reopened"), "")288
_ = s.Store.AddMREvent(r.Context(), repo.ID, mr.ID, u.ID, "reopened", "")289
s.redirect(w, r, repoURL(repo)+"/-/merge-requests/"+strconv.FormatInt(mr.Number, 10), s.tr(r, "flash.reopened"), "")290
}247
}291
248
292
// noteRequestsChanges zet Request changes als de reactie een suggestie bevat.249
// noteRequestsChanges zet Request changes als de reactie een suggestie bevat.@@ -70,7 +70,7 @@ func (s *Server) Handler() http.Handler {
70
70
mux := http.NewServeMux()
71
71
mux.HandleFunc("GET /assets/{file}", s.asset)
72
72
mux.HandleFunc("GET /-/info", s.infoPage)
73
mux.HandleFunc("GET /api/v1/ci/spec", s.ciSpec)
73
s.mountAPI(mux)
74
74
mux.HandleFunc("GET /api/v1/admin/self-update", s.selfUpdateStatus)
75
75
mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)
76
76
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
@@ -131,7 +131,6 @@ func (s *Server) Handler() http.Handler {
131
131
mux.HandleFunc("PUT /api/v1/groups/{path}/secrets/{name}", s.groupSecretUpdateAPI)
132
132
mux.HandleFunc("POST /api/v1/groups/{path}/secrets/{name}/replace", s.groupSecretReplaceAPI)
133
133
mux.HandleFunc("DELETE /api/v1/groups/{path}/secrets/{name}", s.groupSecretDeleteAPI)
134
135
134
mux.HandleFunc("GET /{owner}/{repo}", s.repoHome)
136
135
mux.HandleFunc("GET /{owner}/{repo}/-/tree", s.treeRoot)
137
136
mux.HandleFunc("GET /{owner}/{repo}/-/tree/{path...}", s.tree)
@@ -544,6 +543,7 @@ type View struct {
544
543
Update *UpdateView
545
544
Spec cispec.Doc
546
545
SpecJSON template.JS
546
APIJSON template.JS
547
547
Page string
548
548
Lang string
549
549
HTMLLang string
@@ -70,7 +70,7 @@ func (s *Server) Handler() http.Handler {70
mux := http.NewServeMux()70
mux := http.NewServeMux()71
mux.HandleFunc("GET /assets/{file}", s.asset)71
mux.HandleFunc("GET /assets/{file}", s.asset)72
mux.HandleFunc("GET /-/info", s.infoPage)72
mux.HandleFunc("GET /-/info", s.infoPage)73
mux.HandleFunc("GET /api/v1/ci/spec", s.ciSpec)73
s.mountAPI(mux)74
mux.HandleFunc("GET /api/v1/admin/self-update", s.selfUpdateStatus)74
mux.HandleFunc("GET /api/v1/admin/self-update", s.selfUpdateStatus)75
mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)75
mux.HandleFunc("POST /api/v1/admin/self-update", s.selfUpdate)76
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {76
mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {@@ -131,7 +131,6 @@ func (s *Server) Handler() http.Handler {131
mux.HandleFunc("PUT /api/v1/groups/{path}/secrets/{name}", s.groupSecretUpdateAPI)131
mux.HandleFunc("PUT /api/v1/groups/{path}/secrets/{name}", s.groupSecretUpdateAPI)132
mux.HandleFunc("POST /api/v1/groups/{path}/secrets/{name}/replace", s.groupSecretReplaceAPI)132
mux.HandleFunc("POST /api/v1/groups/{path}/secrets/{name}/replace", s.groupSecretReplaceAPI)133
mux.HandleFunc("DELETE /api/v1/groups/{path}/secrets/{name}", s.groupSecretDeleteAPI)133
mux.HandleFunc("DELETE /api/v1/groups/{path}/secrets/{name}", s.groupSecretDeleteAPI)134
135
mux.HandleFunc("GET /{owner}/{repo}", s.repoHome)134
mux.HandleFunc("GET /{owner}/{repo}", s.repoHome)136
mux.HandleFunc("GET /{owner}/{repo}/-/tree", s.treeRoot)135
mux.HandleFunc("GET /{owner}/{repo}/-/tree", s.treeRoot)137
mux.HandleFunc("GET /{owner}/{repo}/-/tree/{path...}", s.tree)136
mux.HandleFunc("GET /{owner}/{repo}/-/tree/{path...}", s.tree)@@ -544,6 +543,7 @@ type View struct {544
Update *UpdateView543
Update *UpdateView545
Spec cispec.Doc544
Spec cispec.Doc546
SpecJSON template.JS545
SpecJSON template.JS546
APIJSON template.JS547
Page string547
Page string548
Lang string548
Lang string549
HTMLLang string549
HTMLLang string@@ -5,13 +5,11 @@ import (
5
5
"encoding/json"
6
6
"errors"
7
7
"net/http"
8
"os"
9
8
"sort"
10
9
"strconv"
11
10
"strings"
12
11
13
12
"gitlab.com/Timfa/bluegit/internal/access"
14
"gitlab.com/Timfa/bluegit/internal/gitrepo"
15
13
"gitlab.com/Timfa/bluegit/internal/i18n"
16
14
"gitlab.com/Timfa/bluegit/internal/store"
17
15
"gitlab.com/Timfa/bluegit/internal/webhook"
@@ -189,12 +187,8 @@ func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) {
189
187
if !ok || !s.csrfOK(w, r) {
190
188
return
191
189
}
192
vis := r.FormValue("visibility")
193
if vis != "public" {
194
vis = "private"
195
}
196
if err := s.Store.UpdateRepo(r.Context(), repo.ID, r.FormValue("description"), vis); err != nil {
197
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.trErr(r, err))
190
if err := s.opUpdateRepo(r.Context(), s.who(r).User, repo, r.FormValue("description"), r.FormValue("visibility")); err != nil {
191
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
198
192
return
199
193
}
200
194
s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "")
@@ -221,13 +215,8 @@ func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string)
221
215
if !ok || !s.csrfOK(w, r) {
222
216
return
223
217
}
224
role, err := access.ParseRole(r.FormValue("role"))
225
if err != nil {
226
s.redirect(w, r, back, "", s.trErr(r, err))
227
return
228
}
229
if err := s.Store.SetMember(r.Context(), kind, scopeID, r.FormValue("username"), role); err != nil {
230
s.redirect(w, r, back, "", s.trErr(r, err))
218
if err := s.opSetMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username"), r.FormValue("role")); err != nil {
219
s.redirect(w, r, back, "", s.commitProblem(r, err))
231
220
return
232
221
}
233
222
s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "")
@@ -238,7 +227,7 @@ func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind strin
238
227
if !ok || !s.csrfOK(w, r) {
239
228
return
240
229
}
241
if err := s.Store.RemoveMember(r.Context(), kind, scopeID, r.FormValue("username")); err != nil {
230
if err := s.opRemoveMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username")); err != nil {
242
231
s.redirect(w, r, back, "", s.trErr(r, err))
243
232
return
244
233
}
@@ -266,7 +255,7 @@ func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {
266
255
if !ok || !s.csrfOK(w, r) {
267
256
return
268
257
}
269
if err := s.Store.AddProtected(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {
258
if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false); err != nil {
270
259
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err))
271
260
return
272
261
}
@@ -278,7 +267,7 @@ func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {
278
267
if !ok || !s.csrfOK(w, r) {
279
268
return
280
269
}
281
_ = s.Store.RemoveProtected(r.Context(), repo.ID, r.FormValue("pattern"))
270
_ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false)
282
271
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "")
283
272
}
284
273
@@ -485,7 +474,7 @@ func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind stri
485
474
}
486
475
back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")
487
476
id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)
488
_ = s.Store.DeleteWebhook(r.Context(), kind, scopeID, id)
477
_ = s.opDeleteWebhook(r.Context(), s.who(r).User, kind, scopeID, id)
489
478
s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "")
490
479
}
491
480
@@ -494,13 +483,11 @@ func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) {
494
483
if !ok || !s.csrfOK(w, r) {
495
484
return
496
485
}
497
if r.FormValue("confirm") != repo.Name {
498
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.tr(r, "err.confirmDelete"))
486
u := s.who(r).User
487
if err := s.opDeleteRepo(r.Context(), u, repo, r.FormValue("confirm")); err != nil {
488
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))
499
489
return
500
490
}
501
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
502
_ = s.Store.DeleteRepo(r.Context(), repo.ID)
503
_ = os.RemoveAll(dir)
504
491
s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")
505
492
}
506
493
@@ -5,13 +5,11 @@ import (5
"encoding/json"5
"encoding/json"6
"errors"6
"errors"7
"net/http"7
"net/http"8
"os"9
"sort"8
"sort"10
"strconv"9
"strconv"11
"strings"10
"strings"12
11
13
"gitlab.com/Timfa/bluegit/internal/access"12
"gitlab.com/Timfa/bluegit/internal/access"14
"gitlab.com/Timfa/bluegit/internal/gitrepo"15
"gitlab.com/Timfa/bluegit/internal/i18n"13
"gitlab.com/Timfa/bluegit/internal/i18n"16
"gitlab.com/Timfa/bluegit/internal/store"14
"gitlab.com/Timfa/bluegit/internal/store"17
"gitlab.com/Timfa/bluegit/internal/webhook"15
"gitlab.com/Timfa/bluegit/internal/webhook"@@ -189,12 +187,8 @@ func (s *Server) updateRepo(w http.ResponseWriter, r *http.Request) {189
if !ok || !s.csrfOK(w, r) {187
if !ok || !s.csrfOK(w, r) {190
return188
return191
}189
}192
vis := r.FormValue("visibility")190
if err := s.opUpdateRepo(r.Context(), s.who(r).User, repo, r.FormValue("description"), r.FormValue("visibility")); err != nil {193
if vis != "public" {191
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))194
vis = "private"195
}196
if err := s.Store.UpdateRepo(r.Context(), repo.ID, r.FormValue("description"), vis); err != nil {197
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.trErr(r, err))198
return192
return199
}193
}200
s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "")194
s.redirect(w, r, repoURL(repo)+"/-/settings", s.tr(r, "flash.saved"), "")@@ -221,13 +215,8 @@ func (s *Server) memberPost(w http.ResponseWriter, r *http.Request, kind string)221
if !ok || !s.csrfOK(w, r) {215
if !ok || !s.csrfOK(w, r) {222
return216
return223
}217
}224
role, err := access.ParseRole(r.FormValue("role"))218
if err := s.opSetMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username"), r.FormValue("role")); err != nil {225
if err != nil {219
s.redirect(w, r, back, "", s.commitProblem(r, err))226
s.redirect(w, r, back, "", s.trErr(r, err))227
return228
}229
if err := s.Store.SetMember(r.Context(), kind, scopeID, r.FormValue("username"), role); err != nil {230
s.redirect(w, r, back, "", s.trErr(r, err))231
return220
return232
}221
}233
s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "")222
s.redirect(w, r, back, s.tr(r, "flash.memberSaved"), "")@@ -238,7 +227,7 @@ func (s *Server) memberRemove(w http.ResponseWriter, r *http.Request, kind strin238
if !ok || !s.csrfOK(w, r) {227
if !ok || !s.csrfOK(w, r) {239
return228
return240
}229
}241
if err := s.Store.RemoveMember(r.Context(), kind, scopeID, r.FormValue("username")); err != nil {230
if err := s.opRemoveMember(r.Context(), s.who(r).User, kind, scopeID, r.FormValue("username")); err != nil {242
s.redirect(w, r, back, "", s.trErr(r, err))231
s.redirect(w, r, back, "", s.trErr(r, err))243
return232
return244
}233
}@@ -266,7 +255,7 @@ func (s *Server) addProtected(w http.ResponseWriter, r *http.Request) {266
if !ok || !s.csrfOK(w, r) {255
if !ok || !s.csrfOK(w, r) {267
return256
return268
}257
}269
if err := s.Store.AddProtected(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {258
if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false); err != nil {270
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err))259
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", "", s.trErr(r, err))271
return260
return272
}261
}@@ -278,7 +267,7 @@ func (s *Server) removeProtected(w http.ResponseWriter, r *http.Request) {278
if !ok || !s.csrfOK(w, r) {267
if !ok || !s.csrfOK(w, r) {279
return268
return280
}269
}281
_ = s.Store.RemoveProtected(r.Context(), repo.ID, r.FormValue("pattern"))270
_ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), false)282
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "")271
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=branches", s.tr(r, "flash.patternOff"), "")283
}272
}284
273
@@ -485,7 +474,7 @@ func (s *Server) webhookDelete(w http.ResponseWriter, r *http.Request, kind stri485
}474
}486
back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")475
back = strings.Split(back, "?")[0] + scopeTab(kind, "webhooks")487
id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)476
id, _ := strconv.ParseInt(r.FormValue("id"), 10, 64)488
_ = s.Store.DeleteWebhook(r.Context(), kind, scopeID, id)477
_ = s.opDeleteWebhook(r.Context(), s.who(r).User, kind, scopeID, id)489
s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "")478
s.redirect(w, r, back, s.tr(r, "flash.webhookRemoved"), "")490
}479
}491
480
@@ -494,13 +483,11 @@ func (s *Server) deleteRepo(w http.ResponseWriter, r *http.Request) {494
if !ok || !s.csrfOK(w, r) {483
if !ok || !s.csrfOK(w, r) {495
return484
return496
}485
}497
if r.FormValue("confirm") != repo.Name {486
u := s.who(r).User498
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.tr(r, "err.confirmDelete"))487
if err := s.opDeleteRepo(r.Context(), u, repo, r.FormValue("confirm")); err != nil {488
s.redirect(w, r, repoURL(repo)+"/-/settings", "", s.commitProblem(r, err))499
return489
return500
}490
}501
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)502
_ = s.Store.DeleteRepo(r.Context(), repo.ID)503
_ = os.RemoveAll(dir)504
s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")491
s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")505
}492
}506
493
@@ -16,7 +16,7 @@ func (s *Server) noStorageText(r *http.Request) string {
16
16
17
17
func allowsWithoutStorage(r *http.Request) bool {
18
18
switch r.URL.Path {
19
case "/healthz", "/login", "/auth/callback", "/logout", "/setup", "/-/info", "/api/v1/ci/spec", "/api/v1/admin/self-update":
19
case "/healthz", "/login", "/auth/callback", "/logout", "/setup", "/-/info", "/api/v1/ci/spec", "/api/v1/ci/presets", "/api/v1/openapi.json", "/api/v1/admin/storage", "/api/v1/admin/self-update":
20
20
return true
21
21
}
22
22
return strings.HasPrefix(r.URL.Path, "/assets/")
@@ -85,31 +85,13 @@ func (s *Server) setupSave(w http.ResponseWriter, r *http.Request) {
85
85
if _, ok := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {
86
86
return
87
87
}
88
if s.StateDir == "" {
89
s.renderSetup(w, r, s.tr(r, "err.storageSave"), r.FormValue("path"))
90
return
91
}
92
info, err := state.Inspect(r.FormValue("path"))
88
info, moved, err := s.opSetStorage(r.FormValue("path"))
93
89
if err != nil {
94
90
s.renderSetup(w, r, s.trErr(r, err), strings.TrimSpace(r.FormValue("path")))
95
91
return
96
92
}
97
if same, err := samePath(s.StateDir, info.Path); err != nil {
98
s.renderSetup(w, r, s.trErr(r, err), info.Path)
99
return
100
} else if same {
101
s.renderSetup(w, r, s.tr(r, "err.storageSame"), info.Path)
102
return
103
}
104
previous := s.StoragePath()
105
if err := state.Write(s.StateDir, info.Path); err != nil {
106
s.renderSetup(w, r, s.trErr(r, err), info.Path)
107
return
108
}
109
s.AdoptStorage(info.Path)
110
s.RefreshHooks()
111
93
notice := s.tr(r, "err.storageSet", info.Path, state.Format(info.Free))
112
if previous != "" && previous != info.Path {
94
if moved {
113
95
notice = s.tr(r, "err.storageMoved", info.Path, state.Format(info.Free))
114
96
}
115
97
s.redirect(w, r, "/", notice, "")
@@ -16,7 +16,7 @@ func (s *Server) noStorageText(r *http.Request) string {16
16
17
func allowsWithoutStorage(r *http.Request) bool {17
func allowsWithoutStorage(r *http.Request) bool {18
switch r.URL.Path {18
switch r.URL.Path {19
case "/healthz", "/login", "/auth/callback", "/logout", "/setup", "/-/info", "/api/v1/ci/spec", "/api/v1/admin/self-update":19
case "/healthz", "/login", "/auth/callback", "/logout", "/setup", "/-/info", "/api/v1/ci/spec", "/api/v1/ci/presets", "/api/v1/openapi.json", "/api/v1/admin/storage", "/api/v1/admin/self-update":20
return true20
return true21
}21
}22
return strings.HasPrefix(r.URL.Path, "/assets/")22
return strings.HasPrefix(r.URL.Path, "/assets/")@@ -85,31 +85,13 @@ func (s *Server) setupSave(w http.ResponseWriter, r *http.Request) {85
if _, ok := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {85
if _, ok := s.adminOnly(w, r); !ok || !s.csrfOK(w, r) {86
return86
return87
}87
}88
if s.StateDir == "" {88
info, moved, err := s.opSetStorage(r.FormValue("path"))89
s.renderSetup(w, r, s.tr(r, "err.storageSave"), r.FormValue("path"))90
return91
}92
info, err := state.Inspect(r.FormValue("path"))93
if err != nil {89
if err != nil {94
s.renderSetup(w, r, s.trErr(r, err), strings.TrimSpace(r.FormValue("path")))90
s.renderSetup(w, r, s.trErr(r, err), strings.TrimSpace(r.FormValue("path")))95
return91
return96
}92
}97
if same, err := samePath(s.StateDir, info.Path); err != nil {98
s.renderSetup(w, r, s.trErr(r, err), info.Path)99
return100
} else if same {101
s.renderSetup(w, r, s.tr(r, "err.storageSame"), info.Path)102
return103
}104
previous := s.StoragePath()105
if err := state.Write(s.StateDir, info.Path); err != nil {106
s.renderSetup(w, r, s.trErr(r, err), info.Path)107
return108
}109
s.AdoptStorage(info.Path)110
s.RefreshHooks()111
notice := s.tr(r, "err.storageSet", info.Path, state.Format(info.Free))93
notice := s.tr(r, "err.storageSet", info.Path, state.Format(info.Free))112
if previous != "" && previous != info.Path {94
if moved {113
notice = s.tr(r, "err.storageMoved", info.Path, state.Format(info.Free))95
notice = s.tr(r, "err.storageMoved", info.Path, state.Format(info.Free))114
}96
}115
s.redirect(w, r, "/", notice, "")97
s.redirect(w, r, "/", notice, "")@@ -3,7 +3,6 @@ package server
3
3
import (
4
4
"html/template"
5
5
"net/http"
6
"os"
7
6
"strconv"
8
7
"strings"
9
8
@@ -89,99 +88,24 @@ func repoPath(raw string) (string, bool) {
89
88
}
90
89
91
90
func (s *Server) applySuggestions(w http.ResponseWriter, r *http.Request) {
92
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
91
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
93
92
if !ok || !s.csrfOK(w, r) {
94
93
return
95
94
}
96
mr, err := s.mrFromRequest(r, repo.ID)
97
if err != nil || mr.Status != "open" {
98
http.NotFound(w, r)
99
return
100
}
101
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)
102
patterns, err := s.Store.ProtectedPatterns(r.Context(), repo.ID)
95
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
103
96
if err != nil {
104
s.redirect(w, r, back, "", s.trErr(r, err))
105
return
106
}
107
if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {
108
s.redirect(w, r, back, "", s.tr(r, "err.sugBranch", mr.SourceBranch))
109
return
110
}
111
if s.StoragePath() == "" {
112
s.redirect(w, r, back, "", s.tr(r, "err.noStorage"))
113
return
114
}
115
title := strings.TrimSpace(r.FormValue("title"))
116
if title == "" || strings.ContainsAny(title, "\r\n") {
117
s.redirect(w, r, back, "", s.tr(r, "err.sugTitle"))
118
return
119
}
120
notes, err := s.Store.ListNotes(r.Context(), mr.ID)
121
if err != nil {
122
s.redirect(w, r, back, "", s.trErr(r, err))
97
http.NotFound(w, r)
123
98
return
124
99
}
125
byID := map[int64]store.Note{}
126
for _, n := range notes {
127
byID[n.ID] = n
128
}
129
var edits []gitrepo.SuggestionEdit
130
seen := map[int64]bool{}
100
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
101
var ids []int64
131
102
for _, raw := range r.Form["id"] {
132
103
id, err := strconv.ParseInt(raw, 10, 64)
133
if err != nil || seen[id] {
134
continue
104
if err == nil {
105
ids = append(ids, id)
135
106
}
136
seen[id] = true
137
n, ok := byID[id]
138
if !ok || n.Suggestion == "" || n.FilePath == "" {
139
s.redirect(w, r, back, "", s.tr(r, "err.sugGone"))
140
return
141
}
142
edits = append(edits, gitrepo.SuggestionEdit{
143
Path: n.FilePath, Start: n.LineStart, End: n.LineEnd,
144
Base: n.BaseText, Replacement: n.Suggestion,
145
})
146
}
147
if len(edits) == 0 {
148
s.redirect(w, r, back, "", s.tr(r, "err.sugEmpty"))
149
return
150
}
151
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
152
files := map[string]string{}
153
for _, e := range edits {
154
if _, ok := files[e.Path]; ok {
155
continue
156
}
157
body, err := gitrepo.BlobText(r.Context(), s.Git, dir, mr.SourceBranch, e.Path)
158
if err != nil {
159
s.redirect(w, r, back, "", s.tr(r, "err.sugConflict", e.Path, e.Start, e.End))
160
return
161
}
162
files[e.Path] = body
163
}
164
updated, err := gitrepo.ApplySuggestions(files, edits)
165
if err != nil {
166
s.redirect(w, r, back, "", s.trErr(r, err))
167
return
168
}
169
branch := safeRev(mr.SourceBranch, "")
170
if branch == "" {
171
s.redirect(w, r, back, "", s.tr(r, "err.sugBranch", mr.SourceBranch))
172
return
173
}
174
work, err := s.scratchDir("suggest")
175
if err != nil {
176
s.redirect(w, r, back, "", s.commitProblem(r, err))
177
return
178
107
}
179
defer os.RemoveAll(work)
180
email := u.Username + "@users.git.timfalken.com"
181
if err := s.postReceive(r.Context(), repo, u, dir, func() error {
182
return gitrepo.CommitOnBranch(r.Context(), s.Git, dir, work, branch, u.Username, email, title, r.FormValue("description"), updated, role, patterns)
183
}); err != nil {
184
s.redirect(w, r, back, "", s.commitProblem(r, err))
108
if !s.uiOK(w, r, back, s.opApplySuggestions(r.Context(), u, repo, n, r.FormValue("title"), r.FormValue("description"), ids)) {
185
109
return
186
110
}
187
111
s.redirect(w, r, back, s.tr(r, "flash.suggestions"), "")
@@ -3,7 +3,6 @@ package server3
import (3
import (4
"html/template"4
"html/template"5
"net/http"5
"net/http"6
"os"7
"strconv"6
"strconv"8
"strings"7
"strings"9
8
@@ -89,99 +88,24 @@ func repoPath(raw string) (string, bool) {89
}88
}90
89
91
func (s *Server) applySuggestions(w http.ResponseWriter, r *http.Request) {90
func (s *Server) applySuggestions(w http.ResponseWriter, r *http.Request) {92
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)91
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)93
if !ok || !s.csrfOK(w, r) {92
if !ok || !s.csrfOK(w, r) {94
return93
return95
}94
}96
mr, err := s.mrFromRequest(r, repo.ID)95
n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)97
if err != nil || mr.Status != "open" {98
http.NotFound(w, r)99
return100
}101
back := repoURL(repo) + "/-/merge-requests/" + strconv.FormatInt(mr.Number, 10)102
patterns, err := s.Store.ProtectedPatterns(r.Context(), repo.ID)103
if err != nil {96
if err != nil {104
s.redirect(w, r, back, "", s.trErr(r, err))97
http.NotFound(w, r)105
return106
}107
if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {108
s.redirect(w, r, back, "", s.tr(r, "err.sugBranch", mr.SourceBranch))109
return110
}111
if s.StoragePath() == "" {112
s.redirect(w, r, back, "", s.tr(r, "err.noStorage"))113
return114
}115
title := strings.TrimSpace(r.FormValue("title"))116
if title == "" || strings.ContainsAny(title, "\r\n") {117
s.redirect(w, r, back, "", s.tr(r, "err.sugTitle"))118
return119
}120
notes, err := s.Store.ListNotes(r.Context(), mr.ID)121
if err != nil {122
s.redirect(w, r, back, "", s.trErr(r, err))123
return98
return124
}99
}125
byID := map[int64]store.Note{}100
back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")126
for _, n := range notes {101
var ids []int64127
byID[n.ID] = n128
}129
var edits []gitrepo.SuggestionEdit130
seen := map[int64]bool{}131
for _, raw := range r.Form["id"] {102
for _, raw := range r.Form["id"] {132
id, err := strconv.ParseInt(raw, 10, 64)103
id, err := strconv.ParseInt(raw, 10, 64)133
if err != nil || seen[id] {104
if err == nil {134
continue105
ids = append(ids, id)135
}106
}136
seen[id] = true137
n, ok := byID[id]138
if !ok || n.Suggestion == "" || n.FilePath == "" {139
s.redirect(w, r, back, "", s.tr(r, "err.sugGone"))140
return141
}142
edits = append(edits, gitrepo.SuggestionEdit{143
Path: n.FilePath, Start: n.LineStart, End: n.LineEnd,144
Base: n.BaseText, Replacement: n.Suggestion,145
})146
}147
if len(edits) == 0 {148
s.redirect(w, r, back, "", s.tr(r, "err.sugEmpty"))149
return150
}151
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)152
files := map[string]string{}153
for _, e := range edits {154
if _, ok := files[e.Path]; ok {155
continue156
}157
body, err := gitrepo.BlobText(r.Context(), s.Git, dir, mr.SourceBranch, e.Path)158
if err != nil {159
s.redirect(w, r, back, "", s.tr(r, "err.sugConflict", e.Path, e.Start, e.End))160
return161
}162
files[e.Path] = body163
}164
updated, err := gitrepo.ApplySuggestions(files, edits)165
if err != nil {166
s.redirect(w, r, back, "", s.trErr(r, err))167
return168
}169
branch := safeRev(mr.SourceBranch, "")170
if branch == "" {171
s.redirect(w, r, back, "", s.tr(r, "err.sugBranch", mr.SourceBranch))172
return173
}174
work, err := s.scratchDir("suggest")175
if err != nil {176
s.redirect(w, r, back, "", s.commitProblem(r, err))177
return178
}107
}179
defer os.RemoveAll(work)108
if !s.uiOK(w, r, back, s.opApplySuggestions(r.Context(), u, repo, n, r.FormValue("title"), r.FormValue("description"), ids)) {180
email := u.Username + "@users.git.timfalken.com"181
if err := s.postReceive(r.Context(), repo, u, dir, func() error {182
return gitrepo.CommitOnBranch(r.Context(), s.Git, dir, work, branch, u.Username, email, title, r.FormValue("description"), updated, role, patterns)183
}); err != nil {184
s.redirect(w, r, back, "", s.commitProblem(r, err))185
return109
return186
}110
}187
s.redirect(w, r, back, s.tr(r, "flash.suggestions"), "")111
s.redirect(w, r, back, s.tr(r, "flash.suggestions"), "")@@ -9,7 +9,6 @@ import (
9
9
"gitlab.com/Timfa/bluegit/internal/access"
10
10
"gitlab.com/Timfa/bluegit/internal/gitrepo"
11
11
"gitlab.com/Timfa/bluegit/internal/i18n"
12
"gitlab.com/Timfa/bluegit/internal/names"
13
12
)
14
13
15
14
func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
@@ -60,51 +59,24 @@ func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
60
59
}
61
60
62
61
func (s *Server) createTag(w http.ResponseWriter, r *http.Request) {
63
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
62
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
64
63
if !ok || !s.csrfOK(w, r) {
65
64
return
66
65
}
67
66
back := repoURL(repo) + "/-/tags"
68
name := strings.TrimSpace(r.FormValue("name"))
69
if err := names.ValidTag(name); err != nil {
70
s.redirect(w, r, back, "", s.trErr(r, err))
71
return
72
}
73
patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
74
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
75
s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))
76
return
77
}
78
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
79
target := r.FormValue("target")
80
if strings.TrimSpace(target) == "" {
81
target = repo.DefaultBranch
82
}
83
email := u.Username + "@users.git.timfalken.com"
84
if err := s.postReceive(r.Context(), repo, u, dir, func() error {
85
return gitrepo.CreateTag(r.Context(), s.Git, dir, name, target, r.FormValue("message"), u.Username, email)
86
}); err != nil {
87
s.redirect(w, r, back, "", s.trErr(r, err))
67
if !s.uiOK(w, r, back, s.opCreateTag(r.Context(), u, repo, r.FormValue("name"), r.FormValue("target"), r.FormValue("message"))) {
88
68
return
89
69
}
90
70
s.redirect(w, r, back, s.tr(r, "flash.tagCreated"), "")
91
71
}
92
72
93
73
func (s *Server) deleteTag(w http.ResponseWriter, r *http.Request) {
94
_, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
74
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)
95
75
if !ok || !s.csrfOK(w, r) {
96
76
return
97
77
}
98
78
back := repoURL(repo) + "/-/tags"
99
name := strings.TrimSpace(r.FormValue("name"))
100
patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)
101
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {
102
s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))
103
return
104
}
105
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
106
if err := gitrepo.DeleteTag(r.Context(), s.Git, dir, name); err != nil {
107
s.redirect(w, r, back, "", s.trErr(r, err))
79
if !s.uiOK(w, r, back, s.opDeleteTag(r.Context(), u, repo, r.FormValue("name"))) {
108
80
return
109
81
}
110
82
s.redirect(w, r, back, s.tr(r, "flash.tagDeleted"), "")
@@ -145,7 +117,7 @@ func (s *Server) addProtectedTag(w http.ResponseWriter, r *http.Request) {
145
117
return
146
118
}
147
119
back := repoURL(repo) + "/-/settings?tab=tags"
148
if err := s.Store.AddProtectedTag(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {
120
if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), true); err != nil {
149
121
s.redirect(w, r, back, "", s.trErr(r, err))
150
122
return
151
123
}
@@ -157,7 +129,7 @@ func (s *Server) removeProtectedTag(w http.ResponseWriter, r *http.Request) {
157
129
if !ok || !s.csrfOK(w, r) {
158
130
return
159
131
}
160
_ = s.Store.RemoveProtectedTag(r.Context(), repo.ID, r.FormValue("pattern"))
132
_ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), true)
161
133
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=tags", s.tr(r, "flash.tagOff"), "")
162
134
}
163
135
@@ -9,7 +9,6 @@ import (9
"gitlab.com/Timfa/bluegit/internal/access"9
"gitlab.com/Timfa/bluegit/internal/access"10
"gitlab.com/Timfa/bluegit/internal/gitrepo"10
"gitlab.com/Timfa/bluegit/internal/gitrepo"11
"gitlab.com/Timfa/bluegit/internal/i18n"11
"gitlab.com/Timfa/bluegit/internal/i18n"12
"gitlab.com/Timfa/bluegit/internal/names"13
)12
)14
13
15
func (s *Server) tags(w http.ResponseWriter, r *http.Request) {14
func (s *Server) tags(w http.ResponseWriter, r *http.Request) {@@ -60,51 +59,24 @@ func (s *Server) tags(w http.ResponseWriter, r *http.Request) {60
}59
}61
60
62
func (s *Server) createTag(w http.ResponseWriter, r *http.Request) {61
func (s *Server) createTag(w http.ResponseWriter, r *http.Request) {63
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)62
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)64
if !ok || !s.csrfOK(w, r) {63
if !ok || !s.csrfOK(w, r) {65
return64
return66
}65
}67
back := repoURL(repo) + "/-/tags"66
back := repoURL(repo) + "/-/tags"68
name := strings.TrimSpace(r.FormValue("name"))67
if !s.uiOK(w, r, back, s.opCreateTag(r.Context(), u, repo, r.FormValue("name"), r.FormValue("target"), r.FormValue("message"))) {69
if err := names.ValidTag(name); err != nil {70
s.redirect(w, r, back, "", s.trErr(r, err))71
return72
}73
patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)74
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {75
s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))76
return77
}78
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)79
target := r.FormValue("target")80
if strings.TrimSpace(target) == "" {81
target = repo.DefaultBranch82
}83
email := u.Username + "@users.git.timfalken.com"84
if err := s.postReceive(r.Context(), repo, u, dir, func() error {85
return gitrepo.CreateTag(r.Context(), s.Git, dir, name, target, r.FormValue("message"), u.Username, email)86
}); err != nil {87
s.redirect(w, r, back, "", s.trErr(r, err))88
return68
return89
}69
}90
s.redirect(w, r, back, s.tr(r, "flash.tagCreated"), "")70
s.redirect(w, r, back, s.tr(r, "flash.tagCreated"), "")91
}71
}92
72
93
func (s *Server) deleteTag(w http.ResponseWriter, r *http.Request) {73
func (s *Server) deleteTag(w http.ResponseWriter, r *http.Request) {94
_, repo, role, ok := s.guard(w, r, access.RoleDeveloper)74
u, repo, _, ok := s.guard(w, r, access.RoleDeveloper)95
if !ok || !s.csrfOK(w, r) {75
if !ok || !s.csrfOK(w, r) {96
return76
return97
}77
}98
back := repoURL(repo) + "/-/tags"78
back := repoURL(repo) + "/-/tags"99
name := strings.TrimSpace(r.FormValue("name"))79
if !s.uiOK(w, r, back, s.opDeleteTag(r.Context(), u, repo, r.FormValue("name"))) {100
patterns, _ := s.Store.ProtectedTagPatterns(r.Context(), repo.ID)101
if access.BranchProtected(patterns, name) && !role.CanManageSettings() {102
s.redirect(w, r, back, "", s.tr(r, "err.tagProtected", name))103
return104
}105
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)106
if err := gitrepo.DeleteTag(r.Context(), s.Git, dir, name); err != nil {107
s.redirect(w, r, back, "", s.trErr(r, err))108
return80
return109
}81
}110
s.redirect(w, r, back, s.tr(r, "flash.tagDeleted"), "")82
s.redirect(w, r, back, s.tr(r, "flash.tagDeleted"), "")@@ -145,7 +117,7 @@ func (s *Server) addProtectedTag(w http.ResponseWriter, r *http.Request) {145
return117
return146
}118
}147
back := repoURL(repo) + "/-/settings?tab=tags"119
back := repoURL(repo) + "/-/settings?tab=tags"148
if err := s.Store.AddProtectedTag(r.Context(), repo.ID, r.FormValue("pattern")); err != nil {120
if err := s.opProtect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), true); err != nil {149
s.redirect(w, r, back, "", s.trErr(r, err))121
s.redirect(w, r, back, "", s.trErr(r, err))150
return122
return151
}123
}@@ -157,7 +129,7 @@ func (s *Server) removeProtectedTag(w http.ResponseWriter, r *http.Request) {157
if !ok || !s.csrfOK(w, r) {129
if !ok || !s.csrfOK(w, r) {158
return130
return159
}131
}160
_ = s.Store.RemoveProtectedTag(r.Context(), repo.ID, r.FormValue("pattern"))132
_ = s.opUnprotect(r.Context(), s.who(r).User, repo, r.FormValue("pattern"), true)161
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=tags", s.tr(r, "flash.tagOff"), "")133
s.redirect(w, r, repoURL(repo)+"/-/settings?tab=tags", s.tr(r, "flash.tagOff"), "")162
}134
}163
135
@@ -53,7 +53,13 @@
53
53
{{end}}
54
54
{{end}}
55
55
{{if .ShowUpdate}}{{template "updatestatus" .}}{{end}}
56
<h2 id="api">{{t "info.api.title"}}</h2>
57
<p>{{t "info.api.lead"}}</p>
58
<p>{{t "info.api.auth"}}</p>
59
<p>{{t "info.api.ssh"}}</p>
60
<p><a href="/api/v1/openapi.json">{{t "info.api.spec"}}</a></p>
56
61
<script type="application/json" id="bluegit-ci-spec">{{.SpecJSON}}</script>
62
<script type="application/json" id="bluegit-api">{{.APIJSON}}</script>
57
63
</article>
58
64
{{template "layout-end" .}}
59
65
{{end}}
@@ -53,7 +53,13 @@53
{{end}}53
{{end}}54
{{end}}54
{{end}}55
{{if .ShowUpdate}}{{template "updatestatus" .}}{{end}}55
{{if .ShowUpdate}}{{template "updatestatus" .}}{{end}}56
<h2 id="api">{{t "info.api.title"}}</h2>57
<p>{{t "info.api.lead"}}</p>58
<p>{{t "info.api.auth"}}</p>59
<p>{{t "info.api.ssh"}}</p>60
<p><a href="/api/v1/openapi.json">{{t "info.api.spec"}}</a></p>56
<script type="application/json" id="bluegit-ci-spec">{{.SpecJSON}}</script>61
<script type="application/json" id="bluegit-ci-spec">{{.SpecJSON}}</script>62
<script type="application/json" id="bluegit-api">{{.APIJSON}}</script>57
</article>63
</article>58
{{template "layout-end" .}}64
{{template "layout-end" .}}59
{{end}}65
{{end}}@@ -0,0 +1,58 @@
1
package sshd
2
3
import (
4
"bytes"
5
"context"
6
"io"
7
"testing"
8
9
"gitlab.com/Timfa/bluegit/internal/store"
10
"golang.org/x/crypto/ssh"
11
)
12
13
type memCh struct {
14
in bytes.Reader
15
out bytes.Buffer
16
err bytes.Buffer
17
}
18
19
func (m *memCh) Read(p []byte) (int, error) { return m.in.Read(p) }
20
func (m *memCh) Write(p []byte) (int, error) { return m.out.Write(p) }
21
func (m *memCh) Close() error { return nil }
22
func (m *memCh) CloseWrite() error { return nil }
23
func (m *memCh) SendRequest(string, bool, []byte) (bool, error) {
24
return true, nil
25
}
26
func (m *memCh) Stderr() io.ReadWriter { return &m.err }
27
28
func TestAPICommandUsesHook(t *testing.T) {
29
var gotMethod, gotPath, gotBody string
30
s := &Server{API: func(_ context.Context, user store.User, method, path string, body []byte) (int, []byte) {
31
if user.Username != "ada" {
32
t.Fatalf("user %s", user.Username)
33
}
34
gotMethod, gotPath, gotBody = method, path, string(body)
35
return 200, []byte(`{"username":"ada"}`)
36
}}
37
ch := &memCh{}
38
ch.in.Reset([]byte(`{"name":"x"}`))
39
code := s.execGit(ch, store.User{Username: "ada"}, `api POST /api/v1/user/tokens`)
40
if code != 0 || gotMethod != "POST" || gotPath != "/api/v1/user/tokens" || gotBody != `{"name":"x"}` {
41
t.Fatalf("code %d %s %s %s", code, gotMethod, gotPath, gotBody)
42
}
43
if ch.out.String() != `{"username":"ada"}` || ch.err.String() != "status 200\n" {
44
t.Fatalf("out %q err %q", ch.out.String(), ch.err.String())
45
}
46
47
ch = &memCh{}
48
s.API = func(context.Context, store.User, string, string, []byte) (int, []byte) {
49
return 403, []byte(`{"message":"nee"}`)
50
}
51
if s.execGit(ch, store.User{Username: "ada"}, "api GET /api/v1/projects") != 1 {
52
t.Fatal("verwacht exit 1")
53
}
54
if ch.err.String() != "status 403\n" || ch.out.String() != `{"message":"nee"}` {
55
t.Fatalf("out %q err %q", ch.out.String(), ch.err.String())
56
}
57
var _ ssh.Channel = ch
58
}
@@ -0,0 +1,58 @@1
package sshd2
3
import (4
"bytes"5
"context"6
"io"7
"testing"8
9
"gitlab.com/Timfa/bluegit/internal/store"10
"golang.org/x/crypto/ssh"11
)12
13
type memCh struct {14
in bytes.Reader15
out bytes.Buffer16
err bytes.Buffer17
}18
19
func (m *memCh) Read(p []byte) (int, error) { return m.in.Read(p) }20
func (m *memCh) Write(p []byte) (int, error) { return m.out.Write(p) }21
func (m *memCh) Close() error { return nil }22
func (m *memCh) CloseWrite() error { return nil }23
func (m *memCh) SendRequest(string, bool, []byte) (bool, error) {24
return true, nil25
}26
func (m *memCh) Stderr() io.ReadWriter { return &m.err }27
28
func TestAPICommandUsesHook(t *testing.T) {29
var gotMethod, gotPath, gotBody string30
s := &Server{API: func(_ context.Context, user store.User, method, path string, body []byte) (int, []byte) {31
if user.Username != "ada" {32
t.Fatalf("user %s", user.Username)33
}34
gotMethod, gotPath, gotBody = method, path, string(body)35
return 200, []byte(`{"username":"ada"}`)36
}}37
ch := &memCh{}38
ch.in.Reset([]byte(`{"name":"x"}`))39
code := s.execGit(ch, store.User{Username: "ada"}, `api POST /api/v1/user/tokens`)40
if code != 0 || gotMethod != "POST" || gotPath != "/api/v1/user/tokens" || gotBody != `{"name":"x"}` {41
t.Fatalf("code %d %s %s %s", code, gotMethod, gotPath, gotBody)42
}43
if ch.out.String() != `{"username":"ada"}` || ch.err.String() != "status 200\n" {44
t.Fatalf("out %q err %q", ch.out.String(), ch.err.String())45
}46
47
ch = &memCh{}48
s.API = func(context.Context, store.User, string, string, []byte) (int, []byte) {49
return 403, []byte(`{"message":"nee"}`)50
}51
if s.execGit(ch, store.User{Username: "ada"}, "api GET /api/v1/projects") != 1 {52
t.Fatal("verwacht exit 1")53
}54
if ch.err.String() != "status 403\n" || ch.out.String() != `{"message":"nee"}` {55
t.Fatalf("out %q err %q", ch.out.String(), ch.err.String())56
}57
var _ ssh.Channel = ch58
}@@ -11,6 +11,7 @@ import (
11
11
"encoding/pem"
12
12
"errors"
13
13
"fmt"
14
"io"
14
15
"log/slog"
15
16
"net"
16
17
"os"
@@ -28,6 +29,10 @@ import (
28
29
// PushFunc krijgt het verschil in refs na een geslaagde push.
29
30
type PushFunc func(repo store.Repo, user store.User, before, after map[string]string)
30
31
32
// APIFunc voert een API-verzoek uit als de eigenaar van de SSH-sleutel.
33
// De webserver zet hem, omdat dit pakket de server niet mag importeren.
34
type APIFunc func(ctx context.Context, user store.User, method, path string, body []byte) (int, []byte)
35
31
36
// Server is de git-SSH-listener.
32
37
type Server struct {
33
38
Listen string
@@ -37,6 +42,7 @@ type Server struct {
37
42
HostKey string
38
43
Log *slog.Logger
39
44
OnPush PushFunc
45
API APIFunc
40
46
// kex vervangt de standaardlijst. Tests zetten hier een korte lijst.
41
47
kex []string
42
48
mu sync.RWMutex
@@ -156,6 +162,10 @@ func (s *Server) session(channel ssh.Channel, requests <-chan *ssh.Request, user
156
162
}
157
163
158
164
func (s *Server) execGit(channel ssh.Channel, user store.User, command string) int {
165
fields := splitCmd(command)
166
if len(fields) > 0 && fields[0] == "api" {
167
return s.execAPI(channel, user, fields)
168
}
159
169
if s.storage() == "" {
160
170
fmt.Fprintln(channel.Stderr(), "Opslag is nog niet ingesteld. De beheerder kiest een pad in de webinterface.")
161
171
return 1
@@ -220,6 +230,31 @@ func (s *Server) execGit(channel ssh.Channel, user store.User, command string) i
220
230
return 0
221
231
}
222
232
233
func (s *Server) execAPI(channel ssh.Channel, user store.User, fields []string) int {
234
if s.API == nil {
235
fmt.Fprintln(channel.Stderr(), "api niet beschikbaar")
236
return 1
237
}
238
if len(fields) < 3 {
239
fmt.Fprintln(channel.Stderr(), "gebruik: api METHOD pad")
240
return 1
241
}
242
body, err := io.ReadAll(io.LimitReader(channel, 1<<20))
243
if err != nil {
244
fmt.Fprintln(channel.Stderr(), err.Error())
245
return 1
246
}
247
code, out := s.API(context.Background(), user, strings.ToUpper(fields[1]), fields[2], body)
248
if len(out) > 0 {
249
_, _ = channel.Write(out)
250
}
251
fmt.Fprintf(channel.Stderr(), "status %d\n", code)
252
if code >= 400 {
253
return 1
254
}
255
return 0
256
}
257
223
258
func parseCommand(command string) (service, repo string, err error) {
224
259
fields := splitCmd(command)
225
260
if len(fields) != 2 {
@@ -11,6 +11,7 @@ import (11
"encoding/pem"11
"encoding/pem"12
"errors"12
"errors"13
"fmt"13
"fmt"14
"io"14
"log/slog"15
"log/slog"15
"net"16
"net"16
"os"17
"os"@@ -28,6 +29,10 @@ import (28
// PushFunc krijgt het verschil in refs na een geslaagde push.29
// PushFunc krijgt het verschil in refs na een geslaagde push.29
type PushFunc func(repo store.Repo, user store.User, before, after map[string]string)30
type PushFunc func(repo store.Repo, user store.User, before, after map[string]string)30
31
32
// APIFunc voert een API-verzoek uit als de eigenaar van de SSH-sleutel.33
// De webserver zet hem, omdat dit pakket de server niet mag importeren.34
type APIFunc func(ctx context.Context, user store.User, method, path string, body []byte) (int, []byte)35
31
// Server is de git-SSH-listener.36
// Server is de git-SSH-listener.32
type Server struct {37
type Server struct {33
Listen string38
Listen string@@ -37,6 +42,7 @@ type Server struct {37
HostKey string42
HostKey string38
Log *slog.Logger43
Log *slog.Logger39
OnPush PushFunc44
OnPush PushFunc45
API APIFunc40
// kex vervangt de standaardlijst. Tests zetten hier een korte lijst.46
// kex vervangt de standaardlijst. Tests zetten hier een korte lijst.41
kex []string47
kex []string42
mu sync.RWMutex48
mu sync.RWMutex@@ -156,6 +162,10 @@ func (s *Server) session(channel ssh.Channel, requests <-chan *ssh.Request, user156
}162
}157
163
158
func (s *Server) execGit(channel ssh.Channel, user store.User, command string) int {164
func (s *Server) execGit(channel ssh.Channel, user store.User, command string) int {165
fields := splitCmd(command)166
if len(fields) > 0 && fields[0] == "api" {167
return s.execAPI(channel, user, fields)168
}159
if s.storage() == "" {169
if s.storage() == "" {160
fmt.Fprintln(channel.Stderr(), "Opslag is nog niet ingesteld. De beheerder kiest een pad in de webinterface.")170
fmt.Fprintln(channel.Stderr(), "Opslag is nog niet ingesteld. De beheerder kiest een pad in de webinterface.")161
return 1171
return 1@@ -220,6 +230,31 @@ func (s *Server) execGit(channel ssh.Channel, user store.User, command string) i220
return 0230
return 0221
}231
}222
232
233
func (s *Server) execAPI(channel ssh.Channel, user store.User, fields []string) int {234
if s.API == nil {235
fmt.Fprintln(channel.Stderr(), "api niet beschikbaar")236
return 1237
}238
if len(fields) < 3 {239
fmt.Fprintln(channel.Stderr(), "gebruik: api METHOD pad")240
return 1241
}242
body, err := io.ReadAll(io.LimitReader(channel, 1<<20))243
if err != nil {244
fmt.Fprintln(channel.Stderr(), err.Error())245
return 1246
}247
code, out := s.API(context.Background(), user, strings.ToUpper(fields[1]), fields[2], body)248
if len(out) > 0 {249
_, _ = channel.Write(out)250
}251
fmt.Fprintf(channel.Stderr(), "status %d\n", code)252
if code >= 400 {253
return 1254
}255
return 0256
}257
223
func parseCommand(command string) (service, repo string, err error) {258
func parseCommand(command string) (service, repo string, err error) {224
fields := splitCmd(command)259
fields := splitCmd(command)225
if len(fields) != 2 {260
if len(fields) != 2 {@@ -777,6 +777,29 @@ func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, ex
777
777
return n > 0, err
778
778
}
779
779
780
// RetryJob zet een mislukte of geannuleerde job terug in de wachtrij.
781
func (s *Store) RetryJob(ctx context.Context, id int64) (bool, error) {
782
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', finished_at = NULL WHERE id = ? AND status IN ('failed', 'canceled')`, id)
783
if err != nil {
784
return false, err
785
}
786
n, _ := res.RowsAffected()
787
if n == 1 {
788
_, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)
789
}
790
return n == 1, nil
791
}
792
793
// CancelJob stopt een job die nog niet klaar is.
794
func (s *Store) CancelJob(ctx context.Context, id int64) (bool, error) {
795
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'canceled', finished_at = ? WHERE id = ? AND status IN ('created', 'pending', 'queued', 'manual', 'running')`, now(), id)
796
if err != nil {
797
return false, err
798
}
799
n, _ := res.RowsAffected()
800
return n == 1, nil
801
}
802
780
803
// QueueJob zet een handmatige job in de wachtrij.
781
804
func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
782
805
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)
@@ -855,6 +878,24 @@ func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePa
855
878
return err
856
879
}
857
880
881
// ListArtifacts toont de bestanden van één job.
882
func (s *Store) ListArtifacts(ctx context.Context, jobID int64) ([]Artifact, error) {
883
rows, err := s.db.QueryContext(ctx, `SELECT id, job_id, path, storage_path, size FROM artifacts WHERE job_id = ? ORDER BY path`, jobID)
884
if err != nil {
885
return nil, err
886
}
887
defer rows.Close()
888
var out []Artifact
889
for rows.Next() {
890
var a Artifact
891
if err := rows.Scan(&a.ID, &a.JobID, &a.Path, &a.StoragePath, &a.Size); err != nil {
892
return nil, err
893
}
894
out = append(out, a)
895
}
896
return out, rows.Err()
897
}
898
858
899
// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
859
900
func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
860
901
var storage string
@@ -777,6 +777,29 @@ func (s *Store) ResourceBusy(ctx context.Context, repoID int64, group string, ex777
return n > 0, err777
return n > 0, err778
}778
}779
779
780
// RetryJob zet een mislukte of geannuleerde job terug in de wachtrij.781
func (s *Store) RetryJob(ctx context.Context, id int64) (bool, error) {782
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued', finished_at = NULL WHERE id = ? AND status IN ('failed', 'canceled')`, id)783
if err != nil {784
return false, err785
}786
n, _ := res.RowsAffected()787
if n == 1 {788
_, _ = s.db.ExecContext(ctx, `UPDATE pipelines SET status = 'running', finished_at = NULL WHERE id = (SELECT pipeline_id FROM jobs WHERE id = ?)`, id)789
}790
return n == 1, nil791
}792
793
// CancelJob stopt een job die nog niet klaar is.794
func (s *Store) CancelJob(ctx context.Context, id int64) (bool, error) {795
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'canceled', finished_at = ? WHERE id = ? AND status IN ('created', 'pending', 'queued', 'manual', 'running')`, now(), id)796
if err != nil {797
return false, err798
}799
n, _ := res.RowsAffected()800
return n == 1, nil801
}802
780
// QueueJob zet een handmatige job in de wachtrij.803
// QueueJob zet een handmatige job in de wachtrij.781
func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {804
func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {782
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)805
res, err := s.db.ExecContext(ctx, `UPDATE jobs SET status = 'queued' WHERE id = ? AND status = 'manual'`, id)@@ -855,6 +878,24 @@ func (s *Store) AddArtifact(ctx context.Context, jobID int64, relPath, storagePa855
return err878
return err856
}879
}857
880
881
// ListArtifacts toont de bestanden van één job.882
func (s *Store) ListArtifacts(ctx context.Context, jobID int64) ([]Artifact, error) {883
rows, err := s.db.QueryContext(ctx, `SELECT id, job_id, path, storage_path, size FROM artifacts WHERE job_id = ? ORDER BY path`, jobID)884
if err != nil {885
return nil, err886
}887
defer rows.Close()888
var out []Artifact889
for rows.Next() {890
var a Artifact891
if err := rows.Scan(&a.ID, &a.JobID, &a.Path, &a.StoragePath, &a.Size); err != nil {892
return nil, err893
}894
out = append(out, a)895
}896
return out, rows.Err()897
}898
858
// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.899
// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.859
func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {900
func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {860
var storage string901
var storage string@@ -95,6 +95,7 @@ func (s *Store) migrate() error {
95
95
`ALTER TABLE notes ADD COLUMN parent_id INTEGER NOT NULL DEFAULT 0`,
96
96
`ALTER TABLE secrets ADD COLUMN invisible INTEGER NOT NULL DEFAULT 0`,
97
97
`ALTER TABLE webhooks ADD COLUMN fields_json TEXT NOT NULL DEFAULT ''`,
98
`ALTER TABLE access_tokens ADD COLUMN scopes TEXT NOT NULL DEFAULT 'api'`,
98
99
}
99
100
for _, q := range alters {
100
101
if _, err := s.db.Exec(q); err != nil && !strings.Contains(strings.ToLower(err.Error()), "duplicate column") {
@@ -646,32 +647,65 @@ type TokenInfo struct {
646
647
ID int64
647
648
Name string
648
649
Prefix string
650
Scopes string
649
651
CreatedAt time.Time
650
652
LastUsedAt time.Time
651
653
ExpiresAt time.Time
652
654
}
653
655
654
// CreateToken maakt een bg_-token. De tekst wordt één keer teruggegeven.
656
// TokenAuth is een geldig token plus de eigenaar.
657
type TokenAuth struct {
658
Token TokenInfo
659
User User
660
}
661
662
// TokenRequest beschrijft een nieuw token. Lege scopes worden api.
663
type TokenRequest struct {
664
Name string
665
Scopes string
666
ExpiresAt time.Time
667
}
668
669
// CreateToken maakt een bg_-token met scope api. De tekst wordt één keer teruggegeven.
655
670
func (s *Store) CreateToken(ctx context.Context, userID int64, name string) (string, error) {
656
name = strings.TrimSpace(name)
671
plain, _, err := s.IssueToken(ctx, userID, TokenRequest{Name: name, Scopes: "api"})
672
return plain, err
673
}
674
675
// IssueToken maakt een token met scopes en een optionele vervaldatum.
676
func (s *Store) IssueToken(ctx context.Context, userID int64, req TokenRequest) (string, TokenInfo, error) {
677
name := strings.TrimSpace(req.Name)
657
678
if name == "" || len(name) > 80 {
658
return "", i18n.E("err.tokenNeedsName")
679
return "", TokenInfo{}, i18n.E("err.tokenNeedsName")
680
}
681
scopes := strings.TrimSpace(req.Scopes)
682
if scopes == "" {
683
scopes = "api"
684
}
685
if !req.ExpiresAt.IsZero() && !req.ExpiresAt.After(time.Now()) {
686
return "", TokenInfo{}, i18n.E("err.tokenExpired")
659
687
}
660
688
plain, err := newToken("bg_")
661
689
if err != nil {
662
return "", err
690
return "", TokenInfo{}, err
691
}
692
var exp any
693
if !req.ExpiresAt.IsZero() {
694
exp = req.ExpiresAt.UTC().Format(time.RFC3339)
663
695
}
664
_, err = s.db.ExecContext(ctx, `INSERT INTO access_tokens (user_id, name, token_hash, prefix, created_at) VALUES (?, ?, ?, ?, ?)`,
665
userID, name, hashToken(plain), plain[:10], now())
696
res, err := s.db.ExecContext(ctx, `INSERT INTO access_tokens (user_id, name, token_hash, prefix, scopes, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,
697
userID, name, hashToken(plain), plain[:10], scopes, now(), exp)
666
698
if err != nil {
667
return "", err
699
return "", TokenInfo{}, err
668
700
}
669
return plain, nil
701
id, _ := res.LastInsertId()
702
info := TokenInfo{ID: id, Name: name, Prefix: plain[:10], Scopes: scopes, CreatedAt: time.Now().UTC(), ExpiresAt: req.ExpiresAt}
703
return plain, info, nil
670
704
}
671
705
672
706
// ListTokens toont de tokens van een gebruiker.
673
707
func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, error) {
674
rows, err := s.db.QueryContext(ctx, `SELECT id, name, prefix, created_at, COALESCE(last_used_at, ''), COALESCE(expires_at, '') FROM access_tokens WHERE user_id = ? ORDER BY id DESC`, userID)
708
rows, err := s.db.QueryContext(ctx, `SELECT id, name, prefix, COALESCE(scopes, 'api'), created_at, COALESCE(last_used_at, ''), COALESCE(expires_at, '') FROM access_tokens WHERE user_id = ? ORDER BY id DESC`, userID)
675
709
if err != nil {
676
710
return nil, err
677
711
}
@@ -680,7 +714,7 @@ func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, erro
680
714
for rows.Next() {
681
715
var t TokenInfo
682
716
var created, used, expires string
683
if err := rows.Scan(&t.ID, &t.Name, &t.Prefix, &created, &used, &expires); err != nil {
717
if err := rows.Scan(&t.ID, &t.Name, &t.Prefix, &t.Scopes, &created, &used, &expires); err != nil {
684
718
return nil, err
685
719
}
686
720
t.CreatedAt = parseTime(created)
@@ -706,19 +740,41 @@ func (s *Store) DeleteToken(ctx context.Context, userID, id int64) error {
706
740
707
741
// UserByToken zoekt de eigenaar van een persoonlijk token.
708
742
func (s *Store) UserByToken(ctx context.Context, token string) (User, error) {
743
auth, err := s.AuthenticateToken(ctx, token)
744
if err != nil {
745
return User{}, err
746
}
747
return auth.User, nil
748
}
749
750
// AuthenticateToken controleert het geheim, de vervaldatum en geeft de scopes terug.
751
func (s *Store) AuthenticateToken(ctx context.Context, token string) (TokenAuth, error) {
709
752
if !strings.HasPrefix(token, "bg_") {
710
return User{}, errNotFound
753
return TokenAuth{}, errNotFound
711
754
}
712
var userID, tokenID int64
713
err := s.db.QueryRowContext(ctx, `SELECT id, user_id FROM access_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&tokenID, &userID)
755
var info TokenInfo
756
var userID int64
757
var created, expires, scopes string
758
err := s.db.QueryRowContext(ctx, `SELECT id, user_id, name, prefix, COALESCE(scopes, 'api'), created_at, COALESCE(expires_at, '') FROM access_tokens WHERE token_hash = ?`, hashToken(token)).
759
Scan(&info.ID, &userID, &info.Name, &info.Prefix, &scopes, &created, &expires)
714
760
if errors.Is(err, sql.ErrNoRows) {
715
return User{}, errNotFound
761
return TokenAuth{}, errNotFound
716
762
}
717
763
if err != nil {
718
return User{}, err
764
return TokenAuth{}, err
765
}
766
info.Scopes = scopes
767
info.CreatedAt = parseTime(created)
768
info.ExpiresAt = parseTime(expires)
769
if !info.ExpiresAt.IsZero() && !info.ExpiresAt.After(time.Now()) {
770
return TokenAuth{}, i18n.E("err.tokenExpired")
771
}
772
_, _ = s.db.ExecContext(ctx, `UPDATE access_tokens SET last_used_at = ? WHERE id = ?`, now(), info.ID)
773
user, err := s.UserByID(ctx, userID)
774
if err != nil {
775
return TokenAuth{}, err
719
776
}
720
_, _ = s.db.ExecContext(ctx, `UPDATE access_tokens SET last_used_at = ? WHERE id = ?`, now(), tokenID)
721
return s.UserByID(ctx, userID)
777
return TokenAuth{Token: info, User: user}, nil
722
778
}
723
779
724
780
// SSHKey is een publieke sleutel voor git-over-SSH.
@@ -95,6 +95,7 @@ func (s *Store) migrate() error {95
`ALTER TABLE notes ADD COLUMN parent_id INTEGER NOT NULL DEFAULT 0`,95
`ALTER TABLE notes ADD COLUMN parent_id INTEGER NOT NULL DEFAULT 0`,96
`ALTER TABLE secrets ADD COLUMN invisible INTEGER NOT NULL DEFAULT 0`,96
`ALTER TABLE secrets ADD COLUMN invisible INTEGER NOT NULL DEFAULT 0`,97
`ALTER TABLE webhooks ADD COLUMN fields_json TEXT NOT NULL DEFAULT ''`,97
`ALTER TABLE webhooks ADD COLUMN fields_json TEXT NOT NULL DEFAULT ''`,98
`ALTER TABLE access_tokens ADD COLUMN scopes TEXT NOT NULL DEFAULT 'api'`,98
}99
}99
for _, q := range alters {100
for _, q := range alters {100
if _, err := s.db.Exec(q); err != nil && !strings.Contains(strings.ToLower(err.Error()), "duplicate column") {101
if _, err := s.db.Exec(q); err != nil && !strings.Contains(strings.ToLower(err.Error()), "duplicate column") {@@ -646,32 +647,65 @@ type TokenInfo struct {646
ID int64647
ID int64647
Name string648
Name string648
Prefix string649
Prefix string650
Scopes string649
CreatedAt time.Time651
CreatedAt time.Time650
LastUsedAt time.Time652
LastUsedAt time.Time651
ExpiresAt time.Time653
ExpiresAt time.Time652
}654
}653
655
654
// CreateToken maakt een bg_-token. De tekst wordt één keer teruggegeven.656
// TokenAuth is een geldig token plus de eigenaar.657
type TokenAuth struct {658
Token TokenInfo659
User User660
}661
662
// TokenRequest beschrijft een nieuw token. Lege scopes worden api.663
type TokenRequest struct {664
Name string665
Scopes string666
ExpiresAt time.Time667
}668
669
// CreateToken maakt een bg_-token met scope api. De tekst wordt één keer teruggegeven.655
func (s *Store) CreateToken(ctx context.Context, userID int64, name string) (string, error) {670
func (s *Store) CreateToken(ctx context.Context, userID int64, name string) (string, error) {656
name = strings.TrimSpace(name)671
plain, _, err := s.IssueToken(ctx, userID, TokenRequest{Name: name, Scopes: "api"})672
return plain, err673
}674
675
// IssueToken maakt een token met scopes en een optionele vervaldatum.676
func (s *Store) IssueToken(ctx context.Context, userID int64, req TokenRequest) (string, TokenInfo, error) {677
name := strings.TrimSpace(req.Name)657
if name == "" || len(name) > 80 {678
if name == "" || len(name) > 80 {658
return "", i18n.E("err.tokenNeedsName")679
return "", TokenInfo{}, i18n.E("err.tokenNeedsName")680
}681
scopes := strings.TrimSpace(req.Scopes)682
if scopes == "" {683
scopes = "api"684
}685
if !req.ExpiresAt.IsZero() && !req.ExpiresAt.After(time.Now()) {686
return "", TokenInfo{}, i18n.E("err.tokenExpired")659
}687
}660
plain, err := newToken("bg_")688
plain, err := newToken("bg_")661
if err != nil {689
if err != nil {662
return "", err690
return "", TokenInfo{}, err691
}692
var exp any693
if !req.ExpiresAt.IsZero() {694
exp = req.ExpiresAt.UTC().Format(time.RFC3339)663
}695
}664
_, err = s.db.ExecContext(ctx, `INSERT INTO access_tokens (user_id, name, token_hash, prefix, created_at) VALUES (?, ?, ?, ?, ?)`,696
res, err := s.db.ExecContext(ctx, `INSERT INTO access_tokens (user_id, name, token_hash, prefix, scopes, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?)`,665
userID, name, hashToken(plain), plain[:10], now())697
userID, name, hashToken(plain), plain[:10], scopes, now(), exp)666
if err != nil {698
if err != nil {667
return "", err699
return "", TokenInfo{}, err668
}700
}669
return plain, nil701
id, _ := res.LastInsertId()702
info := TokenInfo{ID: id, Name: name, Prefix: plain[:10], Scopes: scopes, CreatedAt: time.Now().UTC(), ExpiresAt: req.ExpiresAt}703
return plain, info, nil670
}704
}671
705
672
// ListTokens toont de tokens van een gebruiker.706
// ListTokens toont de tokens van een gebruiker.673
func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, error) {707
func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, error) {674
rows, err := s.db.QueryContext(ctx, `SELECT id, name, prefix, created_at, COALESCE(last_used_at, ''), COALESCE(expires_at, '') FROM access_tokens WHERE user_id = ? ORDER BY id DESC`, userID)708
rows, err := s.db.QueryContext(ctx, `SELECT id, name, prefix, COALESCE(scopes, 'api'), created_at, COALESCE(last_used_at, ''), COALESCE(expires_at, '') FROM access_tokens WHERE user_id = ? ORDER BY id DESC`, userID)675
if err != nil {709
if err != nil {676
return nil, err710
return nil, err677
}711
}@@ -680,7 +714,7 @@ func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, erro680
for rows.Next() {714
for rows.Next() {681
var t TokenInfo715
var t TokenInfo682
var created, used, expires string716
var created, used, expires string683
if err := rows.Scan(&t.ID, &t.Name, &t.Prefix, &created, &used, &expires); err != nil {717
if err := rows.Scan(&t.ID, &t.Name, &t.Prefix, &t.Scopes, &created, &used, &expires); err != nil {684
return nil, err718
return nil, err685
}719
}686
t.CreatedAt = parseTime(created)720
t.CreatedAt = parseTime(created)@@ -706,19 +740,41 @@ func (s *Store) DeleteToken(ctx context.Context, userID, id int64) error {706
740
707
// UserByToken zoekt de eigenaar van een persoonlijk token.741
// UserByToken zoekt de eigenaar van een persoonlijk token.708
func (s *Store) UserByToken(ctx context.Context, token string) (User, error) {742
func (s *Store) UserByToken(ctx context.Context, token string) (User, error) {743
auth, err := s.AuthenticateToken(ctx, token)744
if err != nil {745
return User{}, err746
}747
return auth.User, nil748
}749
750
// AuthenticateToken controleert het geheim, de vervaldatum en geeft de scopes terug.751
func (s *Store) AuthenticateToken(ctx context.Context, token string) (TokenAuth, error) {709
if !strings.HasPrefix(token, "bg_") {752
if !strings.HasPrefix(token, "bg_") {710
return User{}, errNotFound753
return TokenAuth{}, errNotFound711
}754
}712
var userID, tokenID int64755
var info TokenInfo713
err := s.db.QueryRowContext(ctx, `SELECT id, user_id FROM access_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&tokenID, &userID)756
var userID int64757
var created, expires, scopes string758
err := s.db.QueryRowContext(ctx, `SELECT id, user_id, name, prefix, COALESCE(scopes, 'api'), created_at, COALESCE(expires_at, '') FROM access_tokens WHERE token_hash = ?`, hashToken(token)).759
Scan(&info.ID, &userID, &info.Name, &info.Prefix, &scopes, &created, &expires)714
if errors.Is(err, sql.ErrNoRows) {760
if errors.Is(err, sql.ErrNoRows) {715
return User{}, errNotFound761
return TokenAuth{}, errNotFound716
}762
}717
if err != nil {763
if err != nil {718
return User{}, err764
return TokenAuth{}, err765
}766
info.Scopes = scopes767
info.CreatedAt = parseTime(created)768
info.ExpiresAt = parseTime(expires)769
if !info.ExpiresAt.IsZero() && !info.ExpiresAt.After(time.Now()) {770
return TokenAuth{}, i18n.E("err.tokenExpired")771
}772
_, _ = s.db.ExecContext(ctx, `UPDATE access_tokens SET last_used_at = ? WHERE id = ?`, now(), info.ID)773
user, err := s.UserByID(ctx, userID)774
if err != nil {775
return TokenAuth{}, err719
}776
}720
_, _ = s.db.ExecContext(ctx, `UPDATE access_tokens SET last_used_at = ? WHERE id = ?`, now(), tokenID)777
return TokenAuth{Token: info, User: user}, nil721
return s.UserByID(ctx, userID)722
}778
}723
779
724
// SSHKey is een publieke sleutel voor git-over-SSH.780
// SSHKey is een publieke sleutel voor git-over-SSH.