package server
import (
"encoding/json"
"html/template"
"net/http"
"net/url"
"os"
"os/exec"
"strings"
"gitlab.com/Timfa/bluegit/internal/access"
"gitlab.com/Timfa/bluegit/internal/ci"
"gitlab.com/Timfa/bluegit/internal/gitrepo"
"gitlab.com/Timfa/bluegit/internal/highlight"
)
const ciFile = "blue-ci-cd.yml"
const ciMaxBytes = 200_000
// CIEditor is de Pipeline Editor voor blue-ci-cd.yml.
type CIEditor struct {
Ref string
Body string
Rows []EditorLine
Issues []LintRow
Errors int
Warnings int
Status string
Class string
}
// EditorLine is één gekleurde regel, met een markering als de linter daar klaagt.
type EditorLine struct {
N int
HTML template.HTML
Bad bool
}
// LintRow is één melding onder de editor.
type LintRow struct {
Line int `json:"line"`
Text string `json:"text"`
Warning bool `json:"warning"`
}
func (s *Server) ciEditor(w http.ResponseWriter, r *http.Request) {
_, repo, role, ok := s.guard(w, r, access.RoleReadonly)
if !ok {
return
}
ref := strings.TrimSpace(r.URL.Query().Get("ref"))
if ref == "" {
ref = r.URL.Query().Get("rev")
}
ref = safeRev(ref, repo.DefaultBranch)
v := s.repoView(w, r, repo, role, "edit.title")
v.Wide = true
v.Page = "editor"
v.Rev = ref
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
s.branchList(r, &v, dir)
body := s.ciFileAt(r, dir, ref)
model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))
model.Ref = ref
v.Editor = model
s.render(w, "editor", v)
}
func (s *Server) lintCI(w http.ResponseWriter, r *http.Request) {
_, repo, _, ok := s.guard(w, r, access.RoleReadonly)
if !ok || !s.csrfOK(w, r) {
return
}
body := r.FormValue("body")
if len(body) > ciMaxBytes {
http.Error(w, s.tr(r, "edit.fail"), http.StatusBadRequest)
return
}
ref := safeRev(r.FormValue("ref"), repo.DefaultBranch)
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
model := s.ciEditorModel(r, body, s.includeFrom(r, dir, ref))
lines := make([]string, len(model.Rows))
var bad []int
for i, row := range model.Rows {
lines[i] = string(row.HTML)
if row.Bad {
bad = append(bad, row.N)
}
}
w.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(w).Encode(map[string]any{
"status": model.Status,
"statusClass": model.Class,
"errors": model.Errors,
"warnings": model.Warnings,
"issues": model.Issues,
"lines": lines,
"bad": bad,
})
}
func (s *Server) saveCIEditor(w http.ResponseWriter, r *http.Request) {
u, repo, role, ok := s.guard(w, r, access.RoleDeveloper)
if !ok || !s.csrfOK(w, r) {
return
}
base := safeRev(r.FormValue("base"), repo.DefaultBranch)
branch := strings.TrimSpace(r.FormValue("branch"))
if !validBranchName(branch) {
s.redirect(w, r, repoURL(repo)+"/-/ci/editor?ref="+url.QueryEscape(base), "", s.tr(r, "edit.badBranch"))
return
}
back := repoURL(repo) + "/-/ci/editor?ref=" + url.QueryEscape(branch)
message := strings.TrimSpace(r.FormValue("message"))
if message == "" {
s.redirect(w, r, back, "", s.tr(r, "edit.needMessage"))
return
}
body := r.FormValue("body")
if len(body) > ciMaxBytes {
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))
return
}
patterns, _ := s.Store.ProtectedPatterns(r.Context(), repo.ID)
if access.BranchProtected(patterns, branch) && !role.CanPushBranch(true) {
s.redirect(w, r, back, "", s.tr(r, "edit.protected"))
return
}
dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
if err := s.ensureBranch(r, dir, branch, base); err != nil {
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))
return
}
work, err := os.MkdirTemp("", "bluegit-edit-")
if err != nil {
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))
return
}
defer os.RemoveAll(work)
email := u.Username + "@users.git.timfalken.com"
err = gitrepo.CommitOnBranch(r.Context(), s.Git, dir, work, branch, u.Username, email, message, "", map[string]string{ciFile: body}, role, patterns)
if err != nil {
low := strings.ToLower(err.Error())
if strings.Contains(low, "nothing to commit") || strings.Contains(low, "nothing added") {
s.redirect(w, r, back, "", s.tr(r, "edit.same"))
return
}
if s.Log != nil {
s.Log.Error("ci-editor", "err", err)
}
s.redirect(w, r, back, "", s.tr(r, "edit.fail"))
return
}
s.redirect(w, r, back, s.tr(r, "edit.saved"), "")
}
func (s *Server) ciEditorModel(r *http.Request, body string, read func(string) ([]byte, error)) *CIEditor {
_, issues := ci.Lint([]byte(body), read)
bad := map[int]bool{}
var rows []LintRow
errors, warnings := 0, 0
for _, is := range issues {
line := is.Line
if line < 1 {
line = 1
}
text := s.tr(r, is.Key, is.Args...)
rows = append(rows, LintRow{Line: line, Text: text, Warning: is.Warning})
if is.Warning {
warnings++
continue
}
errors++
bad[line] = true
}
painted := highlight.Lines(ciFile, body)
if len(painted) == 0 {
painted = []string{""}
}
if strings.HasSuffix(body, "\n") {
painted = append(painted, "")
}
lines := make([]EditorLine, len(painted))
for i, htmlLine := range painted {
n := i + 1
lines[i] = EditorLine{N: n, HTML: template.HTML(htmlLine), Bad: bad[n]}
}
status, class := s.tr(r, "edit.clean"), "passed"
if errors > 0 {
status, class = s.tr(r, "edit.issues", errors), "failed"
} else if warnings > 0 {
status, class = s.tr(r, "edit.warnings", warnings), "warning"
}
if rows == nil {
rows = []LintRow{}
}
return &CIEditor{
Body: body, Rows: lines, Issues: rows,
Errors: errors, Warnings: warnings, Status: status, Class: class,
}
}
func (s *Server) ciFileAt(r *http.Request, dir, ref string) string {
out, err := exec.CommandContext(r.Context(), s.Git, "-C", dir, "show", ref+":"+ciFile).Output()
if err != nil || len(out) > ciMaxBytes {
return ""
}
return string(out)
}
func (s *Server) includeFrom(r *http.Request, dir, ref string) func(string) ([]byte, error) {
return func(path string) ([]byte, error) {
if !validInclude(path) {
return nil, os.ErrInvalid
}
return exec.CommandContext(r.Context(), s.Git, "-C", dir, "show", ref+":"+path).Output()
}
}
func (s *Server) ensureBranch(r *http.Request, dir, branch, base string) error {
if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+branch) != "" {
return nil
}
if gitOne(r.Context(), s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+base) == "" {
return os.ErrNotExist
}
cmd := exec.CommandContext(r.Context(), s.Git, "-C", dir, "branch", branch, base)
if out, err := cmd.CombinedOutput(); err != nil {
if s.Log != nil {
s.Log.Error("ci-branch", "err", err, "out", string(out))
}
return err
}
return nil
}
func validBranchName(s string) bool {
if s == "" || s == "@" || strings.HasPrefix(s, "-") || strings.HasPrefix(s, "/") || strings.HasSuffix(s, "/") || strings.HasSuffix(s, ".") || strings.Contains(s, "..") || strings.Contains(s, "//") || strings.Contains(s, "@{") {
return false
}
return !strings.ContainsAny(s, " \t\n~^:?*[\\")
}
func validInclude(p string) bool {
if p == "" || strings.HasPrefix(p, "/") || strings.Contains(p, `\`) || strings.Contains(p, "..") {
return false
}
return true
}