BlueGit

timfa bluegit

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>

timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa

Authored 2026-10-22 · 3 weeks ago

Hash
d89195e9e18cd76224d7fdb0b9c42cc1f3cb2d73
Parent
be133ac8
40 files changed +4495 −794
cmd/bluegit/main.go +1 −0
@@ -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 {
internal/access/scope.go added +125 −0
@@ -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 @@
1package access
2
3import (
4 "sort"
5 "strings"
6
7 "gitlab.com/Timfa/bluegit/internal/i18n"
8)
9
10const (
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.
18type ScopeClass int
19
20const (
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).
33type Scopes struct {
34 set map[string]bool
35}
36
37// ParseScopes maakt een opgeslagen lijst. Leeg wordt api.
38func 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.
68func 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
86func (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
95func (s Scopes) APIWrite() bool { return s.set[ScopeAPI] }
96func (s Scopes) APIRead() bool { return s.set[ScopeAPI] || s.set[ScopeReadAPI] }
97func (s Scopes) RepoWrite() bool {
98 return s.set[ScopeAPI] || s.set[ScopeWriteRepo]
99}
100func (s Scopes) RepoRead() bool {
101 return s.RepoWrite() || s.set[ScopeReadRepo]
102}
103
104// Allows meldt of deze scopes de klasse dekken.
105func (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.
123func AllScopes() Scopes {
124 return Scopes{set: map[string]bool{ScopeAPI: true}}
125}
internal/gitrepo/suggest.go +21 −3
@@ -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[stri
113// 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.
115func CommitOnBranch(ctx context.Context, gitBin, bare, work, branch, author, email, title, description string, files map[string]string, role access.Role, patterns []string) error {
115func 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.
120func 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, ema
142 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) != "" {
internal/i18n/catalog_api.go added +68 −0
@@ -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 @@
1package i18n
2
3func init() {
4 addCatalog(en, apiEN)
5 addCatalog(nl, apiNL)
6 addCatalog(de, apiDE)
7 addCatalog(fr, apiFR)
8}
9
10var 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
25var 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
40var 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
55var 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}
internal/server/api.go +15 −93
@@ -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 @@
1package server
1package server
2
2
3import (
3import (
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
19type releaseRequest struct {
15type releaseRequest struct {
@@ -29,116 +25,42 @@ type releaseRequest struct {
29}
25}
30
26
31func (s *Server) createRelease(w http.ResponseWriter, r *http.Request) {
27func (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 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 return
31 return
40 }
32 }
41 token := bearer(r)
33 token := tokenFrom(r)
42 var job store.Job
34 var job store.Job
43 var author int64
35 var author store.User
44 var actor store.User
45 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 return
40 return
50 }
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 return
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 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 return
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 var req releaseRequest
54 var req releaseRequest
69 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 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)
91 return
57 return
92 }
58 }
93 var assets []store.ReleaseAsset
59 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 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)
132 return
61 return
133 }
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
144func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) {
66func (s *Server) releaseAsset(w http.ResponseWriter, r *http.Request) {
internal/server/api_account.go added +198 −0
@@ -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 @@
1package server
2
3import (
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
13func rfcTime(t time.Time) any {
14 if t.IsZero() {
15 return nil
16 }
17 return t.UTC().Format(time.RFC3339)
18}
19
20func 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
31func 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
45func (s *Server) apiGetUser(w http.ResponseWriter, r *http.Request) {
46 writeJSON(w, http.StatusOK, userJSON(apiUser(r), true))
47}
48
49func (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
66func (s *Server) apiExport(w http.ResponseWriter, r *http.Request) {
67 writeJSON(w, http.StatusOK, s.opExport(r.Context(), apiUser(r)))
68}
69
70func (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
79func (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
92func (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
118func (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
130func 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
137func (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
150func (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
165func (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
177func (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}
internal/server/api_collab.go added +726 −0
@@ -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 @@
1package server
2
3import (
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
13func 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
20func 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
27func 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
31func (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
44func (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
61func (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
87func (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
95func (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
116func (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
135func (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
147func (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
159func (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
168func (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
187func (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
210func (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
218func (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
238func (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
256func (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
268func (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
296func (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
308func (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
320func (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
327func (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
335func (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
343func 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
347func (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
376func (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
394func (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
412func (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
419func (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
427func (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
435func 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
442func (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
496func (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
504func (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
512func (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
524func (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
532func (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
540func 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
548func 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
564func (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
591func (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
618func (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
634func (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
646func (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
658func (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
696func (s *Server) apiProtectBranches(w http.ResponseWriter, r *http.Request) {
697 s.apiPatterns(w, r, false)
698}
699
700func (s *Server) apiProtectTags(w http.ResponseWriter, r *http.Request) {
701 s.apiPatterns(w, r, true)
702}
703
704func (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
720func (s *Server) apiUnprotectBranch(w http.ResponseWriter, r *http.Request) {
721 s.apiUnprotect(w, r, false)
722}
723
724func (s *Server) apiUnprotectTag(w http.ResponseWriter, r *http.Request) {
725 s.apiUnprotect(w, r, true)
726}
internal/server/api_flow.go added +586 −0
@@ -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 @@
1package server
2
3import (
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
14func 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
23func (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
59func (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
94func (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
144func (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
167func (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
190func (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
215func (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
231func (s *Server) apiCloseMR(w http.ResponseWriter, r *http.Request) {
232 s.apiSetMR(w, r, false)
233}
234
235func (s *Server) apiReopenMR(w http.ResponseWriter, r *http.Request) {
236 s.apiSetMR(w, r, true)
237}
238
239func (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
259func 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
266func 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
273func (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
305func (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
323func (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
339func (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
365func (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
373func (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
383func (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
395func (s *Server) apiPlayJob(w http.ResponseWriter, r *http.Request) { s.apiJobAction(w, r, "play") }
396func (s *Server) apiRetryJob(w http.ResponseWriter, r *http.Request) {
397 s.apiJobAction(w, r, "retry")
398}
399func (s *Server) apiCancelJob(w http.ResponseWriter, r *http.Request) {
400 s.apiJobAction(w, r, "cancel")
401}
402
403func (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
408func (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
438func (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
454func (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
477func (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
510func (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
530func (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
543func (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
567func (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}
internal/server/api_git.go added +301 −0
@@ -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 @@
1package server
2
3import (
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
13func (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
49func (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
83func (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
116func (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
127func (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
154func (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
175func (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
201func (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
242func 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
249func (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
268func (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}
internal/server/api_http.go added +332 −0
@@ -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 @@
1package server
2
3import (
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
18type actorKey struct{}
19
20type apiActor struct {
21 User store.User
22 Scopes access.Scopes
23 Via string
24}
25
26type apiAuth int
27
28const (
29 authUser apiAuth = iota
30 authPublic
31 authRelease
32)
33
34type apiHandler func(*Server, http.ResponseWriter, *http.Request)
35
36type 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.
48func 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
60func (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
75func (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
111func 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
125func apiUser(r *http.Request) store.User {
126 a, _ := r.Context().Value(actorKey{}).(apiActor)
127 return a.User
128}
129
130func 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
142func 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
152func (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
156func (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
164func 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
179func 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
191func 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.
212func (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
232func (s *Server) openAPI(w http.ResponseWriter, r *http.Request) {
233 writeJSON(w, http.StatusOK, openAPIDoc())
234}
235
236func 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
284func 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
306func 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}
internal/server/api_routes.go added +121 −0
@@ -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 @@
1package server
2
3import (
4 "net/http"
5
6 "gitlab.com/Timfa/bluegit/internal/access"
7)
8
9var 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}
internal/server/api_test.go added +290 −0
@@ -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 @@
1package server
2
3import (
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
19func 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
79func 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}
internal/server/auth_handlers.go +6 −68
@@ -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
13func (s *Server) login(w http.ResponseWriter, r *http.Request) {
10func (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 return
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 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 return
167 return
@@ -181,7 +178,7 @@ func (s *Server) deleteToken(w http.ResponseWriter, r *http.Request) {
181 }
178 }
182 var id int64
179 var id int64
183 _, _ = 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 return
183 return
187 }
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 return
191 return
195 }
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 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))
206 return
195 return
207 }
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 int64
205 var id int64
217 _, _ = 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 return
209 return
221 }
210 }
@@ -227,58 +216,7 @@ func (s *Server) export(w http.ResponseWriter, r *http.Request) {
227 if !ok {
216 if !ok {
228 return
217 return
229 }
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 []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 }
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)
internal/server/branches.go +6 −76
@@ -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 server
3import (
3import (
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
61func (s *Server) createBranch(w http.ResponseWriter, r *http.Request) {
59func (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 return
62 return
65 }
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 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))
90 return
66 return
91 }
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
95func (s *Server) deleteBranch(w http.ResponseWriter, r *http.Request) {
71func (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 return
74 return
99 }
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 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))
119 return
78 return
120 }
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
124func (s *Server) renameBranch(w http.ResponseWriter, r *http.Request) {
83func (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 return
86 return
128 }
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 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))
160 return
90 return
161 }
91 }
162 s.redirect(w, r, back, s.tr(r, "flash.branchRenamed"), "")
92 s.redirect(w, r, back, s.tr(r, "flash.branchRenamed"), "")
internal/server/editor.go +19 −79
@@ -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 @@
1package server
1package server
2
2
3import (
3import (
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 return
106 return
106 }
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 return
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 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
135func (s *Server) saveCIEditor(w http.ResponseWriter, r *http.Request) {
117func (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 return
120 return
139 }
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 return
145 }
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 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 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 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 })
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 return
132 return
185 }
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 return
194 }
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 return
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
315func (s *Server) ensureBranch(r *http.Request, dir, branch, base, work string) error {
255func (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 nil
262 return nil
323 }
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 = env
266 cmd.Env = env
327 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) e
331 }
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 nil
275 return nil
336 }
276 }
337 return i18n.E("edit.failBranch")
277 return i18n.E("edit.failBranch")
338}
278}
339
279
340func (s *Server) gitEnv(r *http.Request, dir string, env []string, args ...string) string {
280func (s *Server) gitEnv(ctx context.Context, dir string, env []string, args ...string) string {
341 bin := s.Git
281 bin := s.Git
342 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 = env
286 cmd.Env = env
347 out, err := cmd.Output()
287 out, err := cmd.Output()
348 if err != nil {
288 if err != nil {
internal/server/git_http.go +15 −5
@@ -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.Role
32 var role access.Role
33 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 return
43 return
44 }
44 }
45 if !scopes.RepoWrite() {
46 http.Error(w, s.tr(r, "err.apiScope"), http.StatusForbidden)
47 return
48 }
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 return
51 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 return
59 return
60 } else if authed && !scopes.RepoRead() {
61 http.Error(w, s.tr(r, "err.apiScope"), http.StatusForbidden)
62 return
56 }
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]string
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
79func (s *Server) gitUser(r *http.Request) (store.User, bool) {
86func (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{}, 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)
102 return auth.User, access.StoredScopes(auth.Token.Scopes), true
92 return u, err == nil
93}
103}
94
104
95func (s *Server) askAuth(w http.ResponseWriter) {
105func (s *Server) askAuth(w http.ResponseWriter) {
internal/server/info.go +1 −0
@@ -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 = true
20 v.Info = true
21 v.Spec = doc
21 v.Spec = doc
22 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}
internal/server/info_test.go +3 −0
@@ -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)
internal/server/media.go +8 −29
@@ -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 return
60 return
61 }
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 return
65 return
66 }
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 return
73 return
74 }
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.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))
90 return
77 return
91 }
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 return
85 return
99 }
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 return
89 return
103 }
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 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
112 }
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, "://") {
internal/server/mr_page.go +4 −18
@@ -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
81func (s *Server) updateMR(w http.ResponseWriter, r *http.Request) {
81func (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 return
84 return
85 }
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 return
89 return
90 }
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 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))
101 return
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 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
internal/server/operr.go added +87 −0
@@ -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 @@
1package server
2
3import (
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.
12type opError struct {
13 status int
14 err error
15}
16
17func (e *opError) Error() string {
18 if e == nil || e.err == nil {
19 return ""
20 }
21 return e.err.Error()
22}
23
24func (e *opError) Unwrap() error {
25 if e == nil {
26 return nil
27 }
28 return e.err
29}
30
31func 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
38func 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
49func (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
66func (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
75func userEmail(name string) string {
76 return name + "@users.git.timfalken.com"
77}
78
79func 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}
internal/server/ops_account.go added +109 −0
@@ -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 @@
1package server
2
3import (
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
14func (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
26func (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
33func (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
46func (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
53func (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
61func (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}
internal/server/ops_ci.go added +257 −0
@@ -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 @@
1package server
2
3import (
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
18func (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
39func (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
105func (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
134func (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
155func (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
192func (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
252func (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}
internal/server/ops_collab.go added +357 −0
@@ -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 @@
1package server
2
3import (
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
17func (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
37func 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
45func (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
66func (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
84func (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
130func (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
144func (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
160func (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
175func (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
189func (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
199func (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
209func (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
217type hookIn struct {
218 Name string
219 Preset string
220 Filter string
221 Events []string
222 Fields webhook.Input
223}
224
225func (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
253func (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
261func (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
278func (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
288func (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
304func (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
316func (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
335func (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}
internal/server/ops_git.go added +238 −0
@@ -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 @@
1package server
2
3import (
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
15func (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
23func (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
51func (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
62func (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
86func (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
120func (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
148func (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
168type fileAction struct {
169 Action string `json:"action"`
170 Path string `json:"file_path"`
171 Content string `json:"content"`
172}
173
174func (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
220func (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}
internal/server/ops_mr.go added +314 −0
@@ -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 @@
1package server
2
3import (
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
16func (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
47func (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
74func (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
124func (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
156func (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
177func (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
256func (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
290func (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}
internal/server/owner.go +1 −17
@@ -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 server
2
2
3import (
3import (
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 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))
34 return
18 return
35 }
19 }
36 s.redirect(w, r, back, s.tr(r, "flash.owner"), "")
20 s.redirect(w, r, back, s.tr(r, "flash.owner"), "")
internal/server/pipeline_page.go +2 −2
@@ -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
403func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {
403func (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 return
406 return
407 }
407 }
@@ -409,7 +409,7 @@ func (s *Server) playJob(w http.ResponseWriter, r *http.Request) {
409 if !ok {
409 if !ok {
410 return
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 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
internal/server/repo_handlers.go +24 −162
@@ -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 server
2
2
3import (
3import (
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
180func (s *Server) createMR(w http.ResponseWriter, r *http.Request) {
178func (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 return
181 return
184 }
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 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))
198 return
185 return
199 }
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
248func (s *Server) createNote(w http.ResponseWriter, r *http.Request) {
226func (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 return
229 return
252 }
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 return
256 }
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 return
234 return
261 }
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 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 }
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 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"))
294 return
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 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
306func (s *Server) mergeMR(w http.ResponseWriter, r *http.Request) {
246func (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 return
249 return
310 }
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 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")
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 return
254 return
330 }
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 return
258 return
339 }
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
345func (s *Server) closeMR(w http.ResponseWriter, r *http.Request) {
263func (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 return
266 return
349 }
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 return
271 return
354 }
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 return
275 return
358 }
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
364func (s *Server) mrFromRequest(r *http.Request, repoID int64) (store.MergeRequest, error) {
280func (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 return
348 return
433 }
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 return
351 return
440 }
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 return
371 return
461 }
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 return
467 }
468 s.redirect(w, r, "/", "", msg)
469 return
470 }
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 return
376 http.Error(w, s.trErr(r, err), http.StatusForbidden)
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"))
482 return
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 s.failCreate(w, r, s.trErr(r, err))
379 s.failCreate(w, r, s.trErr(r, err))
498 return
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 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 return
388 return
513 }
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 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)
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 return
393 return
internal/server/reviews.go +17 −60
@@ -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 return
88 return
89 }
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 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 {
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 return
92 return
102 }
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 return
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 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 return
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
206func (s *Server) postReview(w http.ResponseWriter, r *http.Request) {
197func (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 return
200 return
210 }
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 return
205 return
215 }
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 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))
241 return
209 return
242 }
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
246func (s *Server) dismissReview(w http.ResponseWriter, r *http.Request) {
214func (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 return
217 return
250 }
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 return
222 return
255 }
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 return
260 }
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 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))
268 return
227 return
269 }
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
273func (s *Server) reopenMR(w http.ResponseWriter, r *http.Request) {
232func (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 return
235 return
277 }
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 return
240 return
282 }
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 return
244 return
286 }
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.
internal/server/server.go +2 −2
@@ -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 *UpdateView
543 Update *UpdateView
545 Spec cispec.Doc
544 Spec cispec.Doc
546 SpecJSON template.JS
545 SpecJSON template.JS
546 APIJSON template.JS
547 Page string
547 Page string
548 Lang string
548 Lang string
549 HTMLLang string
549 HTMLLang string
internal/server/settings_handlers.go +11 −24
@@ -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 return
188 return
191 }
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 return
192 return
199 }
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 return
216 return
223 }
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 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))
231 return
220 return
232 }
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 strin
238 if !ok || !s.csrfOK(w, r) {
227 if !ok || !s.csrfOK(w, r) {
239 return
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 s.redirect(w, r, back, "", s.trErr(r, err))
231 s.redirect(w, r, back, "", s.trErr(r, err))
243 return
232 return
244 }
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 return
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 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 return
260 return
272 }
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 return
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 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 stri
485 }
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 return
484 return
496 }
485 }
497 if r.FormValue("confirm") != repo.Name {
486 u := s.who(r).User
498 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 return
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 s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")
491 s.redirect(w, r, "/", s.tr(r, "flash.repoDeleted"), "")
505}
492}
506
493
internal/server/setup.go +3 −21
@@ -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
17func allowsWithoutStorage(r *http.Request) bool {
17func 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 true
20 return true
21 }
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 return
86 return
87 }
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 return
91 }
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 return
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 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, "")
internal/server/suggest.go +8 −84
@@ -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 server
3import (
3import (
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
91func (s *Server) applySuggestions(w http.ResponseWriter, r *http.Request) {
90func (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 return
93 return
95 }
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 return
100 }
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 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))
123 return
98 return
124 }
99 }
125 byID := map[int64]store.Note{}
100 back := repoURL(repo) + "/-/merge-requests/" + r.PathValue("number")
126 for _, n := range notes {
101 var ids []int64
127 byID[n.ID] = n
128 }
129 var edits []gitrepo.SuggestionEdit
130 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 continue
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)
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 return
109 return
186 }
110 }
187 s.redirect(w, r, back, s.tr(r, "flash.suggestions"), "")
111 s.redirect(w, r, back, s.tr(r, "flash.suggestions"), "")
internal/server/tags.go +6 −34
@@ -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
15func (s *Server) tags(w http.ResponseWriter, r *http.Request) {
14func (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
62func (s *Server) createTag(w http.ResponseWriter, r *http.Request) {
61func (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 return
64 return
66 }
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 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))
88 return
68 return
89 }
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
93func (s *Server) deleteTag(w http.ResponseWriter, r *http.Request) {
73func (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 return
76 return
97 }
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 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))
108 return
80 return
109 }
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 return
117 return
146 }
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 return
122 return
151 }
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 return
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 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
internal/server/templates/info.html +6 −0
@@ -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}}
internal/sshd/api_test.go added +58 −0
@@ -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 @@
1package sshd
2
3import (
4 "bytes"
5 "context"
6 "io"
7 "testing"
8
9 "gitlab.com/Timfa/bluegit/internal/store"
10 "golang.org/x/crypto/ssh"
11)
12
13type memCh struct {
14 in bytes.Reader
15 out bytes.Buffer
16 err bytes.Buffer
17}
18
19func (m *memCh) Read(p []byte) (int, error) { return m.in.Read(p) }
20func (m *memCh) Write(p []byte) (int, error) { return m.out.Write(p) }
21func (m *memCh) Close() error { return nil }
22func (m *memCh) CloseWrite() error { return nil }
23func (m *memCh) SendRequest(string, bool, []byte) (bool, error) {
24 return true, nil
25}
26func (m *memCh) Stderr() io.ReadWriter { return &m.err }
27
28func 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}
internal/sshd/server.go +35 −0
@@ -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.
29type PushFunc func(repo store.Repo, user store.User, before, after map[string]string)
30type 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.
34type 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.
32type Server struct {
37type Server struct {
33 Listen string
38 Listen string
@@ -37,6 +42,7 @@ type Server struct {
37 HostKey string
42 HostKey string
38 Log *slog.Logger
43 Log *slog.Logger
39 OnPush PushFunc
44 OnPush PushFunc
45 API APIFunc
40 // kex vervangt de standaardlijst. Tests zetten hier een korte lijst.
46 // kex vervangt de standaardlijst. Tests zetten hier een korte lijst.
41 kex []string
47 kex []string
42 mu sync.RWMutex
48 mu sync.RWMutex
@@ -156,6 +162,10 @@ func (s *Server) session(channel ssh.Channel, requests <-chan *ssh.Request, user
156}
162}
157
163
158func (s *Server) execGit(channel ssh.Channel, user store.User, command string) int {
164func (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 1
171 return 1
@@ -220,6 +230,31 @@ func (s *Server) execGit(channel ssh.Channel, user store.User, command string) i
220 return 0
230 return 0
221}
231}
222
232
233func (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
223func parseCommand(command string) (service, repo string, err error) {
258func 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 {
internal/store/flow.go +41 −0
@@ -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, ex
777 return n > 0, err
777 return n > 0, err
778}
778}
779
779
780// RetryJob zet een mislukte of geannuleerde job terug in de wachtrij.
781func (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.
794func (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// QueueJob zet een handmatige job in de wachtrij.
803// QueueJob zet een handmatige job in de wachtrij.
781func (s *Store) QueueJob(ctx context.Context, id int64) (bool, error) {
804func (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, storagePa
855 return err
878 return err
856}
879}
857
880
881// ListArtifacts toont de bestanden van één job.
882func (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// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
899// ArtifactPath zoekt een bestand van een job in dezelfde pipeline.
859func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
900func (s *Store) ArtifactPath(ctx context.Context, pipelineID int64, jobName, relPath string) (string, error) {
860 var storage string
901 var storage string
internal/store/store.go +73 −17
@@ -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 int64
647 ID int64
647 Name string
648 Name string
648 Prefix string
649 Prefix string
650 Scopes string
649 CreatedAt time.Time
651 CreatedAt time.Time
650 LastUsedAt time.Time
652 LastUsedAt time.Time
651 ExpiresAt time.Time
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.
657type TokenAuth struct {
658 Token TokenInfo
659 User User
660}
661
662// TokenRequest beschrijft een nieuw token. Lege scopes worden api.
663type 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.
655func (s *Store) CreateToken(ctx context.Context, userID int64, name string) (string, error) {
670func (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.
676func (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 "", 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 (?, ?, ?, ?, ?)`,
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 "", 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// ListTokens toont de tokens van een gebruiker.
706// ListTokens toont de tokens van een gebruiker.
673func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, error) {
707func (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, err
710 return nil, err
677 }
711 }
@@ -680,7 +714,7 @@ func (s *Store) ListTokens(ctx context.Context, userID int64) ([]TokenInfo, erro
680 for rows.Next() {
714 for rows.Next() {
681 var t TokenInfo
715 var t TokenInfo
682 var created, used, expires string
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 return nil, err
718 return nil, err
685 }
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.
708func (s *Store) UserByToken(ctx context.Context, token string) (User, error) {
742func (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.
751func (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{}, errNotFound
753 return TokenAuth{}, errNotFound
711 }
754 }
712 var userID, tokenID int64
755 var info TokenInfo
713 err := s.db.QueryRowContext(ctx, `SELECT id, user_id FROM access_tokens WHERE token_hash = ?`, hashToken(token)).Scan(&tokenID, &userID)
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 if errors.Is(err, sql.ErrNoRows) {
760 if errors.Is(err, sql.ErrNoRows) {
715 return User{}, errNotFound
761 return TokenAuth{}, errNotFound
716 }
762 }
717 if err != nil {
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)
777 return TokenAuth{Token: info, User: user}, nil
721 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.