package server import ( "bytes" "context" "encoding/json" "fmt" "html" "image" _ "image/gif" _ "image/jpeg" "image/png" "net/http" "net/url" "os" "strconv" "strings" "gitlab.com/Timfa/bluegit/internal/card" "gitlab.com/Timfa/bluegit/internal/gitrepo" "gitlab.com/Timfa/bluegit/internal/store" ) func (s *Server) cardCache() *card.Cache { if s.cards == nil { s.cards = card.NewCache(128) } return s.cards } func (s *Server) absURL(path string) string { base := strings.TrimRight(s.Cfg.BaseURL, "/") if path == "" { path = "/" } if !strings.HasPrefix(path, "/") { path = "/" + path } return base + path } func (s *Server) lockedRender() card.Render { return card.Locked(s.absURL("/"), s.absURL("/-/card.png?locked=1"), s.absURL("/api/v1/oembed?locked=1")) } // cardForPath bouwt de kaart als anonieme bezoeker. De sessie wordt niet gelezen. func (s *Server) cardForPath(ctx context.Context, path, rawQuery, fragment string) card.Render { path = "/" + strings.Trim(strings.TrimSpace(path), "/") if path == "/" { return s.siteRender(path, rawQuery) } page := s.absURL(path) if rawQuery != "" { page += "?" + rawQuery } img := s.imageFor(path, rawQuery, fragment) oem := s.oembedFor(page) if s.Store == nil { return card.Site(page, img, oem) } if strings.HasPrefix(path, "/groups/") { return s.groupCard(ctx, strings.TrimPrefix(path, "/groups/"), page, img, oem) } if strings.HasPrefix(path, "/users/") { name := strings.Trim(strings.TrimPrefix(path, "/users/"), "/") if i := strings.Index(name, "/"); i >= 0 { name = name[:i] } return s.userCard(ctx, name, page, img, oem) } parts := strings.Split(strings.Trim(path, "/"), "/") if len(parts) < 2 || strings.HasPrefix(parts[0], "-") { return card.Site(page, img, oem) } repo, err := s.Store.RepoByPath(ctx, parts[0], strings.TrimSuffix(parts[1], ".git")) if err != nil { return card.Site(page, img, oem) } if repo.Visibility != "public" { return s.lockedRender() } q, _ := url.ParseQuery(rawQuery) return s.publicRepoCard(ctx, repo, parts[2:], q, fragment, page, img, oem) } func (s *Server) siteRender(path, rawQuery string) card.Render { page := s.absURL(path) if rawQuery != "" { page += "?" + rawQuery } return card.Site(page, s.imageFor(path, rawQuery, ""), s.oembedFor(page)) } func (s *Server) imageFor(path, rawQuery, fragment string) string { v := url.Values{} v.Set("path", path) q, _ := url.ParseQuery(rawQuery) if l := q.Get("L"); l != "" { v.Set("L", l) } else if _, _, ok := card.ParseLines(fragment); ok { v.Set("L", strings.TrimPrefix(strings.TrimSpace(fragment), "#")) } if rev := q.Get("rev"); rev != "" { v.Set("rev", rev) } return s.absURL("/-/card.png?" + v.Encode()) } func (s *Server) oembedFor(page string) string { return s.absURL("/api/v1/oembed?url=" + url.QueryEscape(page)) } func (s *Server) publicRepoCard(ctx context.Context, repo store.Repo, rest []string, q url.Values, fragment, page, img, oem string) card.Render { kind := "" if len(rest) >= 2 && rest[0] == "-" { kind = rest[1] } switch kind { case "blob": return s.fileCard(ctx, repo, strings.Join(rest[2:], "/"), q, fragment, page, img, oem) case "tree": return s.repoCard(ctx, repo, page, img, oem) case "commit": if len(rest) >= 3 { return s.commitCard(ctx, repo, rest[2], page, img, oem) } case "merge-requests": if len(rest) >= 3 && rest[2] != "new" { if n, err := strconv.ParseInt(rest[2], 10, 64); err == nil { return s.mrCard(ctx, repo, n, page, img, oem) } } case "issues": if len(rest) >= 3 { if n, err := strconv.ParseInt(rest[2], 10, 64); err == nil && n > 0 { return s.issueCard(ctx, repo, n, page, img, oem) } } case "pipelines": if len(rest) >= 3 { if n, err := strconv.ParseInt(rest[2], 10, 64); err == nil && n > 0 { return s.pipeCard(ctx, repo, n, page, img, oem) } } case "releases": return s.releaseCard(ctx, repo, page, img, oem) } return s.repoCard(ctx, repo, page, img, oem) } func (s *Server) repoCard(ctx context.Context, repo store.Repo, page, img, oem string) card.Render { prose := card.Excerpt(repo.Description, 180) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) rev := repo.DefaultBranch if prose == "" && s.StoragePath() != "" { if entries, err := gitrepo.Tree(ctx, s.Git, dir, rev, ""); err == nil { readme, _ := findDocs(entries) if readme != "" { if text, binary, err := gitrepo.Blob(ctx, s.Git, dir, rev, readme, 80_000); err == nil && !binary { prose = card.Excerpt(text, 180) } } } } var facts []string if lang := s.repoLanguage(ctx, dir, rev); lang != "" { facts = append(facts, lang) } if counts, _, err := s.Store.StarInfo(ctx, 0, []int64{repo.ID}); err == nil { facts = append(facts, starLabel(counts[repo.ID])) } if s.StoragePath() != "" { if c, err := gitrepo.LastCommit(ctx, s.Git, dir, rev, ""); err == nil && c.SHA != "" { short := c.SHA if len(short) > 8 { short = short[:8] } facts = append(facts, short+" "+card.Clip(c.Subject, 72)) } } return card.Render{Meta: card.Meta{ Title: repo.OwnerPath + "/" + repo.Name, Description: prose, URL: page, Image: img, OEmbed: oem, Theme: "#1f6feb", Kind: "repository", Facts: facts, Initial: repo.Name, }, Avatar: s.avatarForRepo(ctx, repo)} } func (s *Server) fileCard(ctx context.Context, repo store.Repo, rel string, q url.Values, fragment, page, img, oem string) card.Render { rel, err := cleanRel(rel) base := s.repoCard(ctx, repo, page, img, oem) if err != nil || rel == "" || s.StoragePath() == "" { return base } rev := safeRev(q.Get("rev"), repo.DefaultBranch) dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) text, binary, err := gitrepo.Blob(ctx, s.Git, dir, rev, rel, 80_000) name := rel if i := strings.LastIndex(rel, "/"); i >= 0 { name = rel[i+1:] } from, to, ranged := lineBounds(q, fragment) desc := "Binary file" if err == nil && !binary { desc = card.Snippet(text, from, to, ranged) } facts := []string{repo.OwnerPath + "/" + repo.Name} if lang := langByName(name); lang != "" { facts = append(facts, lang) } if ranged { if from == to { facts = append(facts, fmt.Sprintf("L%d", from)) } else { facts = append(facts, fmt.Sprintf("L%d-%d", from, to)) } } return card.Render{Meta: card.Meta{ Title: name, Description: desc, URL: page, Image: img, OEmbed: oem, Theme: "#1f6feb", Kind: "file", Facts: facts, Initial: name, }, Avatar: base.Avatar} } func (s *Server) commitCard(ctx context.Context, repo store.Repo, sha, page, img, oem string) card.Render { base := s.repoCard(ctx, repo, page, img, oem) if !safeSHA(sha) || s.StoragePath() == "" { return base } dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) c, err := gitrepo.Show(ctx, s.Git, dir, sha) if err != nil { return base } short := c.SHA if len(short) > 8 { short = short[:8] } facts := []string{c.Author, short} if changes, err := gitrepo.CommitFileChanges(ctx, s.Git, dir, c.SHA); err == nil { add, del := 0, 0 for _, ch := range changes { add += ch.Added del += ch.Deleted } facts = append(facts, fmt.Sprintf("+%d โˆ’%d", add, del), fmt.Sprintf("%d files", len(changes))) } return card.Render{Meta: card.Meta{ Title: card.Clip(c.Subject, 90), Description: card.Excerpt(c.Body, 180), URL: page, Image: img, OEmbed: oem, Theme: "#0c3f86", Kind: "commit", Facts: facts, Initial: c.Author, }, Avatar: base.Avatar} } func (s *Server) mrCard(ctx context.Context, repo store.Repo, number int64, page, img, oem string) card.Render { base := s.repoCard(ctx, repo, page, img, oem) mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number) if err != nil { return base } status := mr.Status if mr.Draft && status == "open" { status = "draft" } facts := []string{status, mr.SourceBranch + " โ†’ " + mr.TargetBranch, mr.Author} if s.StoragePath() != "" { dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name) if changes, err := gitrepo.CompareChanges(ctx, s.Git, dir, mr.TargetBranch, mr.SourceBranch); err == nil { add, del := 0, 0 for _, ch := range changes { add += ch.Added del += ch.Deleted } facts = append(facts, fmt.Sprintf("+%d โˆ’%d", add, del)) } } if p, err := s.Store.LatestMergePipeline(ctx, repo.ID, mr.ID); err == nil { jobs, _ := s.Store.JobsByPipeline(ctx, p.ID) facts = append(facts, displayStatus(p.Status, jobs)) } theme := "#1f6feb" switch status { case "merged": theme = "#146c43" case "closed": theme = "#5c6b80" } return card.Render{Meta: card.Meta{ Title: "!" + strconv.FormatInt(mr.Number, 10) + " " + mr.Title, Description: card.Excerpt(mr.Description, 180), URL: page, Image: img, OEmbed: oem, Theme: theme, Kind: "merge_request", Facts: facts, Initial: mr.Author, }, Avatar: base.Avatar} } func (s *Server) issueCard(ctx context.Context, repo store.Repo, number int64, page, img, oem string) card.Render { iss, err := s.Store.IssueByNumber(ctx, repo.ID, number) if err != nil { return s.repoCard(ctx, repo, page, img, oem) } if iss.Confidential { return s.lockedRender() } var labels []string for _, l := range iss.Labels { labels = append(labels, l.Name) } facts := []string{iss.Status} if len(labels) > 0 { facts = append(facts, strings.Join(labels, ", ")) } facts = append(facts, iss.Author) return card.Render{Meta: card.Meta{ Title: "#" + strconv.FormatInt(iss.Number, 10) + " " + iss.Title, Description: card.Excerpt(iss.Description, 180), URL: page, Image: img, OEmbed: oem, Theme: "#9a6700", Kind: "issue", Facts: facts, Initial: iss.Author, }, Avatar: s.avatarForRepo(ctx, repo)} } func (s *Server) pipeCard(ctx context.Context, repo store.Repo, id int64, page, img, oem string) card.Render { base := s.repoCard(ctx, repo, page, img, oem) p, err := s.Store.PipelineByID(ctx, repo.ID, id) if err != nil { return base } jobs, _ := s.Store.JobsByPipeline(ctx, p.ID) status := displayStatus(p.Status, jobs) theme := "#1f6feb" switch status { case "passed": theme = "#146c43" case "failed": theme = "#9f2d2d" case "running": theme = "#9a6700" } facts := []string{status} if p.Ref != "" { facts = append(facts, strings.TrimPrefix(p.Ref, "refs/heads/")) } if p.CommitTitle != "" { facts = append(facts, card.Clip(p.CommitTitle, 72)) } if p.Actor != "" { facts = append(facts, p.Actor) } return card.Render{Meta: card.Meta{ Title: "#" + strconv.FormatInt(p.ID, 10) + " " + status, Description: card.Excerpt(p.CommitTitle, 180), URL: page, Image: img, OEmbed: oem, Theme: theme, Kind: "pipeline", Facts: facts, Initial: repo.Name, }, Avatar: base.Avatar} } func (s *Server) releaseCard(ctx context.Context, repo store.Repo, page, img, oem string) card.Render { base := s.repoCard(ctx, repo, page, img, oem) list, err := s.Store.ListReleases(ctx, repo.ID) if err != nil || len(list) == 0 { return card.Render{Meta: card.Meta{ Title: "Releases", Description: repo.OwnerPath + "/" + repo.Name, URL: page, Image: img, OEmbed: oem, Theme: "#146c43", Kind: "release", Initial: repo.Name, }, Avatar: base.Avatar} } rel := list[0] title := rel.Tag if rel.Name != "" { title = rel.Tag + " ยท " + rel.Name } return card.Render{Meta: card.Meta{ Title: title, Description: card.Excerpt(rel.Body, 180), URL: page, Image: img, OEmbed: oem, Theme: "#146c43", Kind: "release", Facts: []string{repo.OwnerPath + "/" + repo.Name, rel.Tag}, Initial: repo.Name, }, Avatar: base.Avatar} } func (s *Server) groupCard(ctx context.Context, rest, page, img, oem string) card.Render { name := rest if i := strings.Index(name, "/"); i >= 0 { name = name[:i] } g, err := s.Store.GroupByPath(ctx, name) if err != nil { return card.Site(page, img, oem) } if g.Visibility != "public" { return s.lockedRender() } n, _ := s.Store.CountRepos(ctx, "group", g.ID, true) return card.Render{Meta: card.Meta{ Title: g.Name, Description: card.Excerpt(g.Description, 180), URL: page, Image: img, OEmbed: oem, Theme: "#6f42c1", Kind: "group", Facts: []string{repoLabel(n)}, Initial: g.Name, }, Avatar: s.readLogo("group", g.ID, g.LogoMIME)} } func (s *Server) userCard(ctx context.Context, name, page, img, oem string) card.Render { u, err := s.Store.UserByUsername(ctx, name) if err != nil { return card.Site(page, img, oem) } n, _ := s.Store.CountRepos(ctx, "user", u.ID, true) return card.Render{Meta: card.Meta{ Title: u.Username, Description: "Public profile", URL: page, Image: img, OEmbed: oem, Theme: "#1f6feb", Kind: "user", Facts: []string{repoLabel(n)}, Initial: u.Username, }} } func (s *Server) avatarForRepo(ctx context.Context, repo store.Repo) []byte { if b := s.readLogo("repo", repo.ID, repo.LogoMIME); len(b) > 0 { return b } if repo.OwnerKind != "group" { return nil } g, err := s.Store.GroupByID(ctx, repo.OwnerID) if err != nil { return nil } return s.readLogo("group", g.ID, g.LogoMIME) } func (s *Server) readLogo(kind string, id int64, mime string) []byte { if mime != "image/png" && mime != "image/jpeg" && mime != "image/gif" { return nil } path, err := s.logoPath(kind, id) if err != nil { return nil } data, err := os.ReadFile(path) if err != nil { return nil } img, _, err := image.Decode(bytes.NewReader(data)) if err != nil { return nil } var buf bytes.Buffer if err := png.Encode(&buf, img); err != nil { return nil } return buf.Bytes() } func (s *Server) repoLanguage(ctx context.Context, dir, rev string) string { if s.StoragePath() == "" { return "" } entries, err := gitrepo.TreeAll(ctx, s.Git, dir, rev) if err != nil { return "" } counts := map[string]int{} for _, e := range entries { if e.Type != "blob" { continue } if strings.Contains(e.Name, "vendor/") || strings.Contains(e.Name, "node_modules/") { continue } if lang := langByName(e.Name); lang != "" { counts[lang]++ } } best, n := "", 0 for lang, c := range counts { if c > n || (c == n && lang < best) { best, n = lang, c } } return best } func langByName(name string) string { low := strings.ToLower(name) if i := strings.LastIndex(low, "/"); i >= 0 { low = low[i+1:] } ext := "" if i := strings.LastIndex(low, "."); i >= 0 { ext = low[i:] } if lang, ok := extLang[ext]; ok { return lang } switch low { case "dockerfile": return "Dockerfile" case "makefile": return "Makefile" default: return "" } } var extLang = map[string]string{ ".go": "Go", ".py": "Python", ".js": "JavaScript", ".jsx": "JavaScript", ".ts": "TypeScript", ".tsx": "TypeScript", ".rs": "Rust", ".java": "Java", ".rb": "Ruby", ".php": "PHP", ".c": "C", ".h": "C", ".cpp": "C++", ".cc": "C++", ".cs": "C#", ".swift": "Swift", ".kt": "Kotlin", ".html": "HTML", ".css": "CSS", ".scss": "SCSS", ".vue": "Vue", ".sh": "Shell", ".yml": "YAML", ".yaml": "YAML", ".sql": "SQL", ".lua": "Lua", } func starLabel(n int) string { if n == 1 { return "1 star" } return strconv.Itoa(n) + " stars" } func repoLabel(n int) string { if n == 1 { return "1 repository" } return strconv.Itoa(n) + " repositories" } func lineBounds(q url.Values, fragment string) (from, to int, ok bool) { if from, to, ok = card.ParseLines(fragment); ok { return from, to, true } return card.ParseLines(q.Get("L")) } func (s *Server) cardPNG(w http.ResponseWriter, r *http.Request) { var rend card.Render if r.URL.Query().Get("locked") == "1" { rend = s.lockedRender() } else { path := r.URL.Query().Get("path") if !strings.HasPrefix(path, "/") || strings.Contains(path, "..") || strings.Contains(path, "\\") { http.NotFound(w, r) return } q := url.Values{} if l := r.URL.Query().Get("L"); l != "" { q.Set("L", l) } if rev := r.URL.Query().Get("rev"); rev != "" { q.Set("rev", rev) } rend = s.cardForPath(r.Context(), path, q.Encode(), "") } svg := card.SVG(rend) pngBytes, hit := s.cardCache().Get(svg) if !hit { var err error pngBytes, err = card.Raster(svg) if err != nil { http.Error(w, "card", http.StatusInternalServerError) return } s.cardCache().Put(svg, pngBytes) } w.Header().Set("Content-Type", "image/png") w.Header().Set("Cache-Control", "public, max-age=300") w.Header().Set("X-Content-Type-Options", "nosniff") if hit { w.Header().Set("X-Card-Cache", "hit") } else { w.Header().Set("X-Card-Cache", "miss") } _, _ = w.Write(pngBytes) } func (s *Server) oembed(w http.ResponseWriter, r *http.Request) { var rend card.Render if r.URL.Query().Get("locked") == "1" { rend = s.lockedRender() } else { raw := r.URL.Query().Get("url") u, err := url.Parse(raw) if err != nil || u.Path == "" { http.NotFound(w, r) return } rend = s.cardForPath(r.Context(), u.Path, u.RawQuery, u.Fragment) } w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Cache-Control", "no-store") _ = json.NewEncoder(w).Encode(map[string]any{ "version": "1.0", "type": "link", "title": rend.Title, "description": rend.Blurb(), "provider_name": "BlueGit", "provider_url": s.absURL("/"), "thumbnail_url": rend.Image, "thumbnail_width": card.Width, "thumbnail_height": card.Height, }) } func (s *Server) writeLockedCard(w http.ResponseWriter, r *http.Request) { m := s.lockedRender().Meta w.Header().Set("Content-Type", "text/html; charset=utf-8") w.Header().Set("Cache-Control", "no-store") w.Header().Set("X-Robots-Tag", "noindex") w.WriteHeader(http.StatusOK) title := html.EscapeString(m.Title) fmt.Fprintf(w, `%s%s

%s

`, title, metaHTML(m), title) } func metaHTML(m card.Meta) string { esc := html.EscapeString var b strings.Builder fmt.Fprintf(&b, ``, esc(m.Theme)) fmt.Fprintf(&b, ``, esc(m.Blurb())) b.WriteString(``) b.WriteString(``) fmt.Fprintf(&b, ``, esc(m.Title)) fmt.Fprintf(&b, ``, esc(m.Blurb())) fmt.Fprintf(&b, ``, esc(m.URL)) fmt.Fprintf(&b, ``, esc(m.Image)) b.WriteString(``) fmt.Fprintf(&b, ``, card.Width) fmt.Fprintf(&b, ``, card.Height) b.WriteString(``) fmt.Fprintf(&b, ``, esc(m.Title)) fmt.Fprintf(&b, ``, esc(m.Blurb())) fmt.Fprintf(&b, ``, esc(m.Image)) fmt.Fprintf(&b, ``, esc(m.OEmbed)) return b.String() } func isCrawler(r *http.Request) bool { ua := strings.ToLower(r.Header.Get("User-Agent")) for _, name := range []string{ "discordbot", "slackbot", "twitterbot", "facebookexternalhit", "linkedinbot", "telegrambot", "whatsapp", "embedly", "iframely", "redditbot", "pinterestbot", "skypeuripreview", } { if strings.Contains(ua, name) { return true } } return false }