doc/README: update for v1.4.2

Dockerfile

@@ -1,6 +1,6 @@
 # Dockerfile for production Teafolio deployments
 
-FROM golang:1.19-alpine AS builder
+FROM golang:1.22-alpine AS builder
 
 WORKDIR /app
 COPY . .
@@ -10,6 +10,5 @@ FROM alpine:latest
 
 WORKDIR /app
 COPY --from=builder /app/teafolio /app/teafolio
-COPY /static /app/static
 
 ENTRYPOINT [ "/app/teafolio" ]

README.md

@@ -31,6 +31,26 @@ dokku storage:mount teafolio /srv/teafolio-dokku/config.toml:/app/config.toml
 
 ## CHANGELOG
 
+2025-06-01 v1.4.2
+- Proxy images from Gitea, for servers using `REQUIRE_SIGNIN_VIEW=expensive`
+- Always use fallback markdown renderer
+- Fix missing support for markdown tables in fallback renderer
+- Fix very wide code blocks overflowing page width
+
+2024-03-19 v1.4.1
+- Add cooldown for failed markdown API calls
+- Fix missing extra html elements when using fallback markdown renderer
+
+2024-03-19 v1.4.0
+- Support using application token for Gitea API
+- Add fallback to internal markdown renderer if Gitea's API is unavailable
+- Add fallback to Gitea page redirect if there are any errors building repo page
+- Embed static web assets in binary (requires Go 1.16+)
+
+2022-12-31 v1.3.1
+- Fix missing images on homepage
+- Fix an issue with wrong mtime comparisons for updated repositories
+
 2022-12-31 v1.3.0
 - Add `OverrideOrder` configuration option to insert repos at specific positions
 - Cache target image URLs to improve homepage load performance

config.toml.sample

@@ -5,6 +5,7 @@ BindTo="0.0.0.0:5656"
 [Gitea]
 URL="https://gitea.com/"
 Org="gitea"
+Token="" # Must have misc:write, org:read, repo:read permission
 MaxConnections=2 # Use zero for unlimited
 
 [Redirect]

gitea/apiclient.go

@@ -1,7 +1,6 @@
 package gitea
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -9,20 +8,23 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
+	"sync/atomic"
 	"time"
-
-	"golang.org/x/sync/semaphore"
 )
 
 type APIClient struct {
 	urlBase string
 	orgName string
-	apiSem  *semaphore.Weighted
+	token   string
+
+	apiSem chan struct{}
+
+	lastMarkdownFailure atomic.Int64
 }
 
 // NewAPIClient creates a new Gitea API client for a single Gitea organization.
 // Set maxConnections to 0 for unlimited concurrent API calls.
-func NewAPIClient(urlBase string, orgName string, maxConnections int64) *APIClient {
+func NewAPIClient(urlBase string, orgName string, token string, maxConnections int64) *APIClient {
 
 	if !strings.HasSuffix(urlBase, `/`) {
 		urlBase += `/`
@@ -31,17 +33,31 @@ func NewAPIClient(urlBase string, orgName string, maxConnections int64) *APIClie
 	ret := &APIClient{
 		urlBase: urlBase,
 		orgName: orgName,
+		token:   token,
 	}
 
 	if maxConnections == 0 { // unlimited
-		ret.apiSem = semaphore.NewWeighted(99999)
+		// no-op
 	} else {
-		ret.apiSem = semaphore.NewWeighted(maxConnections)
+		ret.apiSem = make(chan struct{}, maxConnections)
 	}
 
 	return ret
 }
 
+func (ac *APIClient) Sem() func() {
+	if ac.apiSem == nil {
+		// No connection limit
+		return func() {}
+	}
+
+	// Connection limit
+	ac.apiSem <- struct{}{}
+	return func() {
+		<-ac.apiSem
+	}
+}
+
 func (ac *APIClient) PopulateCommitInfo(ctx context.Context, rr *Repo) error {
 
 	// The most recent commit will be the head of one of the branches (easy to find)
@@ -87,17 +103,18 @@ func (ac *APIClient) PopulateImages(ctx context.Context, rr *Repo) error {
 }
 
 func (ac *APIClient) apiRequest(ctx context.Context, endpoint string, target interface{}) error {
-	err := ac.apiSem.Acquire(ctx, 1)
-	if err != nil {
-		return err // e.g. ctx closed
-	}
-	defer ac.apiSem.Release(1)
+	release := ac.Sem()
+	defer release()
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ac.urlBase+endpoint, nil)
 	if err != nil {
 		return err
 	}
 
+	if ac.token != "" {
+		req.Header.Set(`Authorization`, `token `+ac.token)
+	}
+
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
 		return err
@@ -215,11 +232,8 @@ func (ac *APIClient) RepoFile(ctx context.Context, repo, filename string) ([]byt
 }
 
 func (ac *APIClient) filesInDirectory(ctx context.Context, repo, dir string) ([]ReaddirEntry, error) {
-	err := ac.apiSem.Acquire(ctx, 1)
-	if err != nil {
-		return nil, err // e.g. ctx closed
-	}
-	defer ac.apiSem.Release(1)
+	release := ac.Sem()
+	defer release()
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, ac.urlBase+`api/v1/repos/`+url.PathEscape(ac.orgName)+`/`+url.PathEscape(repo)+`/contents/`+dir, nil) // n.b. $dir param not escaped
 	if err != nil {
@@ -290,68 +304,3 @@ func (ac *APIClient) topicsForRepo(ctx context.Context, repo string) ([]string,
 
 	return tr.Topics, nil
 }
-
-// renderMarkdown calls the remote Gitea server's own markdown renderer.
-func (ac *APIClient) RenderMarkdown(ctx context.Context, repoName string, body string) ([]byte, error) {
-	err := ac.apiSem.Acquire(ctx, 1)
-	if err != nil {
-		return nil, err // e.g. ctx closed
-	}
-	defer ac.apiSem.Release(1)
-
-	jb, err := json.Marshal(MarkdownRequest{
-		Context: ac.urlBase + url.PathEscape(ac.orgName) + `/` + url.PathEscape(repoName) + `/src/branch/master`,
-		Mode:    "gfm", // magic constant - Github Flavoured Markdown
-		Text:    body,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, ac.urlBase+`api/v1/markdown/`, bytes.NewReader(jb))
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set(`Content-Type`, `application/json`)
-	req.Header.Set(`Content-Length`, fmt.Sprintf("%d", len(jb)))
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
-	}
-
-	return ioutil.ReadAll(resp.Body)
-}
-
-// renderMarkdownRaw calls the remote Gitea server's own markdown renderer.
-func (ac *APIClient) renderMarkdownRaw(ctx context.Context, body []byte) ([]byte, error) {
-	err := ac.apiSem.Acquire(ctx, 1)
-	if err != nil {
-		return nil, err // e.g. ctx closed
-	}
-	defer ac.apiSem.Release(1)
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, ac.urlBase+`api/v1/markdown/raw`, bytes.NewReader(body))
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set(`Content-Type`, `text/plain`)
-	req.Header.Set(`Content-Length`, fmt.Sprintf("%d", len(body)))
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return nil, fmt.Errorf("HTTP %d", resp.StatusCode)
-	}
-
-	return ioutil.ReadAll(resp.Body)
-}

go.mod

@@ -4,5 +4,6 @@ go 1.19
 
 require (
 	github.com/BurntSushi/toml v0.3.1
-	golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a
 )
+
+require github.com/yuin/goldmark v1.7.8 // indirect

go.sum

@@ -1,4 +1,8 @@
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/yuin/goldmark v1.7.0 h1:EfOIvIMZIzHdB/R/zVrikYLPPwJlfMcNczJFMs1m6sA=
+github.com/yuin/goldmark v1.7.0/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
+github.com/yuin/goldmark v1.7.8 h1:iERMLn0/QJeHFhxSt3p6PeN9mGnvIKSpG9YYorDMnic=
+github.com/yuin/goldmark v1.7.8/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
 golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a h1:WXEvlFVvvGxCJLG6REjsT03iWnKLEWinaScsxF2Vm2o=
 golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

main.go

@@ -10,13 +10,15 @@ import (
 	"teafolio/gitea"
 
 	"github.com/BurntSushi/toml"
+	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/extension"
 )
 
 type Config struct {
 	BindTo string
 	Gitea  struct {
-		URL, Org       string
-		MaxConnections int64
+		URL, Org, Token string
+		MaxConnections  int64
 	}
 	Redirect map[string]string
 	Template struct {
@@ -30,19 +32,28 @@ type Config struct {
 type Application struct {
 	cfg Config
 
-	rxRepoPage, rxRepoImage *regexp.Regexp
+	rxRepoPage   *regexp.Regexp
+	rxRepoImage  *regexp.Regexp
+	rxRepoImage2 *regexp.Regexp
 
 	gitea *gitea.APIClient
+	md    goldmark.Markdown
 
 	reposMut               sync.RWMutex
 	reposCache             []gitea.Repo // Sorted by recently-created-first
+	reposCacheByName       map[string]int
 	reposAlphabeticalOrder map[string]int
 }
 
 func main() {
 	app := Application{
-		rxRepoPage:  regexp.MustCompile(`^/([^/]+)/?$`),
-		rxRepoImage: regexp.MustCompile(`^/:banner/([^/]+)/?$`),
+		rxRepoPage:   regexp.MustCompile(`^/([^/]+)/?$`),
+		rxRepoImage:  regexp.MustCompile(`^/:banner/([^/]+)/?$`),
+		rxRepoImage2: regexp.MustCompile(`^/:repo-img/([0-9]+)/([^/]+)/?$`),
+
+		md: goldmark.New(
+			goldmark.WithExtensions(extension.GFM), // required for table rendering support
+		),
 	}
 
 	configFile := flag.String(`ConfigFile`, `config.toml`, `Configuration file in TOML format`)
@@ -54,7 +65,7 @@ func main() {
 	}
 
 	// Create Gitea API client
-	app.gitea = gitea.NewAPIClient(app.cfg.Gitea.URL, app.cfg.Gitea.Org, app.cfg.Gitea.MaxConnections)
+	app.gitea = gitea.NewAPIClient(app.cfg.Gitea.URL, app.cfg.Gitea.Org, app.cfg.Gitea.Token, app.cfg.Gitea.MaxConnections)
 
 	// Sync worker
 	go app.syncWorker(context.Background())

page_imageredir.go

@@ -4,12 +4,12 @@ import (
 	"net/http"
 )
 
-func (this *Application) Bannerpage(w http.ResponseWriter, r *http.Request, repoName string) {
+func (this *Application) Bannerpage(w http.ResponseWriter, r *http.Request, repoName string, imageIdx int) {
 
 	this.reposMut.RLock()
 	defer this.reposMut.RUnlock()
 
-	ridx, ok := this.reposAlphabeticalOrder[repoName]
+	ridx, ok := this.reposCacheByName[repoName]
 	if !ok {
 		w.Header().Set(`Location`, `/static/no_image.png`)
 		w.WriteHeader(301)
@@ -17,12 +17,20 @@ func (this *Application) Bannerpage(w http.ResponseWriter, r *http.Request, repo
 	}
 
 	images := this.reposCache[ridx].Images
-	if len(images) == 0 {
+	if imageIdx >= len(images) {
 		w.Header().Set(`Location`, `/static/no_image.png`)
 		w.WriteHeader(301)
 		return
 	}
 
-	w.Header().Set(`Location`, images[0].RawURL)
-	w.WriteHeader(301)
+	// Mirror serving
+	// (Direct 301 redirects are no longer available)
+
+	imgData, err := this.gitea.RepoFile(r.Context(), repoName, images[imageIdx].Path)
+	if err != nil {
+		http.Error(w, err.Error(), 500)
+		return
+	}
+
+	w.Write(imgData)
 }

page_repository.go

@@ -4,9 +4,12 @@ import (
 	"bytes"
 	"fmt"
 	"html"
+	"log"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
+	"teafolio/gitea"
 )
 
 func (this *Application) Repopage(w http.ResponseWriter, r *http.Request, repoName string) {
@@ -16,7 +19,8 @@ func (this *Application) Repopage(w http.ResponseWriter, r *http.Request, repoNa
 
 	readme, err := this.gitea.RepoFile(ctx, repoName, `README.md`)
 	if err != nil {
-		this.internalError(w, r, fmt.Errorf("loading README.md: %w", err))
+		log.Printf("%s %s: %s", r.Method, r.URL.Path, err)
+		http.Redirect(w, r, repoURL, http.StatusTemporaryRedirect)
 		return
 	}
 
@@ -53,19 +57,27 @@ func (this *Application) Repopage(w http.ResponseWriter, r *http.Request, repoNa
 		lines = append([]string{lines[0], lines[1], extraBadgesMd, ""}, lines[2:]...)
 	}
 
-	readmeHtml, err := this.gitea.RenderMarkdown(ctx, repoName, strings.Join(lines, "\n"))
+	buff := bytes.Buffer{}
+	err = this.md.Convert([]byte(strings.Join(lines, "\n")), &buff)
+
 	if err != nil {
-		this.internalError(w, r, fmt.Errorf("rendering markdown: %w", err))
+		// Built-in markdown renderer didn't work either
+		log.Printf("%s %s: %s", r.Method, r.URL.Path, fmt.Errorf("rendering markdown: %w", err))
+		http.Redirect(w, r, repoURL, http.StatusTemporaryRedirect)
 		return
 	}
 
+	readmeHtml := buff.Bytes()
 	readmeHtml = []byte(strings.Replace(string(readmeHtml), `%%REPLACEME__BADGE%%`, `<img src="/static/build_success_brightgreen.svg" style="width:90px;height:20px;">`, 1))
 
-	images, err := this.gitea.ImageFilesForRepo(ctx, repoName)
-	if err != nil {
-		this.internalError(w, r, fmt.Errorf("listing images: %w", err))
-		return
+	// Use cached image list, since the idx numbers need to match the :repo-img/##
+	// which only uses a cached lookup
+	var images []gitea.ReaddirEntry
+	this.reposMut.RLock()
+	if cacheIdx, ok := this.reposCacheByName[repoName]; ok {
+		images = this.reposCache[cacheIdx].Images
 	}
+	this.reposMut.RUnlock()
 
 	// If the Git repository contains a top-level go.mod file, allow vanity imports
 	if goMod, err := this.gitea.RepoFile(ctx, repoName, `go.mod`); err == nil {
@@ -97,8 +109,12 @@ func (this *Application) Repopage(w http.ResponseWriter, r *http.Request, repoNa
 
 		if len(images) > 0 {
 			fmt.Fprint(w, `<div class="projimg">`)
-			for _, img := range images {
-				fmt.Fprint(w, `<a href="`+html.EscapeString(img.RawURL)+`"><img alt="" class="thumbimage" src="`+html.EscapeString(img.RawURL)+`" /></a>`)
+			for imgIdx, img := range images {
+				// Direct link
+				// fmt.Fprint(w, `<a href="`+html.EscapeString(img.RawURL)+`"><img alt="" class="thumbimage" src="`+html.EscapeString(img.RawURL)+`" /></a>`)
+
+				// Proxied image
+				fmt.Fprint(w, `<a href="`+html.EscapeString(img.RawURL)+`"><img alt="" class="thumbimage" src="/:repo-img/`+strconv.Itoa(imgIdx)+`/`+html.EscapeString(repoName)+`" /></a>`)
 			}
 			fmt.Fprint(w, `</div>`)
 		}

router.go

@@ -1,13 +1,22 @@
 package main
 
 import (
+	"embed"
 	"encoding/base64"
 	"fmt"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 )
 
+//go:embed static/*
+var StaticFiles embed.FS
+
+func (this *Application) ServeStatic(w http.ResponseWriter, r *http.Request) {
+	http.FileServer(http.FS(StaticFiles)).ServeHTTP(w, r)
+}
+
 func (this *Application) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	if r.Method == `GET` {
 		if r.URL.Path == `/` {
@@ -21,7 +30,15 @@ func (this *Application) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			http.Error(w, "not found", 404)
 
 		} else if parts := this.rxRepoImage.FindStringSubmatch(r.URL.Path); parts != nil {
-			this.Bannerpage(w, r, parts[1])
+			this.Bannerpage(w, r, parts[1], 0) // 0th image
+
+		} else if parts := this.rxRepoImage2.FindStringSubmatch(r.URL.Path); parts != nil {
+			imageIdx, err := strconv.Atoi(parts[1])
+			if err != nil {
+				http.Error(w, "Invalid request", 400)
+				return
+			}
+			this.Bannerpage(w, r, parts[2], imageIdx) // 0th image
 
 		} else if parts := this.rxRepoPage.FindStringSubmatch(r.URL.Path); parts != nil {
 
@@ -56,8 +73,9 @@ func (this *Application) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 			this.Repopage(w, r, repoName)
 
-		} else if r.URL.Path == `/static/logo.png` {
-			if this.cfg.Template.CustomLogoPngBase64 != "" {
+		} else if strings.HasPrefix(r.URL.Path, `/static/`) {
+
+			if r.URL.Path == `/static/logo.png` && this.cfg.Template.CustomLogoPngBase64 != "" {
 
 				logoPng, err := base64.StdEncoding.DecodeString(this.cfg.Template.CustomLogoPngBase64)
 				if err != nil {
@@ -69,16 +87,12 @@ func (this *Application) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 				w.Header().Set(`Content-Type`, `image/png`)
 				w.WriteHeader(200)
 				w.Write(logoPng)
-
-			} else {
-				r.URL.Path = r.URL.Path[8:]
-				http.FileServer(http.Dir(`static`)).ServeHTTP(w, r)
-
+				return
 			}
 
-		} else if strings.HasPrefix(r.URL.Path, `/static/`) {
-			r.URL.Path = r.URL.Path[8:]
-			http.FileServer(http.Dir(`static`)).ServeHTTP(w, r)
+			// Embedded resource
+			// r.URL.Path = r.URL.Path[8:]
+			this.ServeStatic(w, r)
 
 		} else if r.URL.Query().Get("go-get") == "1" {
 			// This wasn't one of our standard `/repo` paths, but there is the ?go-get=1 parameter

static/style.css

@@ -28,6 +28,10 @@ h1 a:hover {
 h1 {
 	margin-top:0;
 }
+pre {
+	/* wide codeblocks should scroll */
+	overflow-y: auto;
+}
 .code {
 	background: #F8F8F8;
 	font-family:Consolas,monospace;

sync.go

@@ -94,7 +94,7 @@ func (this *Application) sync(ctx context.Context) (bool, error) {
 	}
 
 	for i, rr := range repos {
-		if idx, ok := this.reposAlphabeticalOrder[rr.Name]; ok && this.reposCache[idx].GiteaUpdated == rr.GiteaUpdated {
+		if idx, ok := this.reposCacheByName[rr.Name]; ok && this.reposCache[idx].GiteaUpdated == rr.GiteaUpdated {
 			// Already exists in cache with same Gitea update time
 			// Copy timestamps
 			repos[i] = this.reposCache[idx]
@@ -117,6 +117,11 @@ func (this *Application) sync(ctx context.Context) (bool, error) {
 				log.Printf("loading topics for '%s': %s", rr.Name, err)
 			}
 
+			err = this.gitea.PopulateImages(ctx, &rr)
+			if err != nil {
+				log.Printf("loading images for '%s': %s", rr.Name, err)
+			}
+
 			// Save
 			repos[i] = rr
 		}
@@ -151,9 +156,15 @@ func (this *Application) sync(ctx context.Context) (bool, error) {
 		repos = reordered
 	}
 
+	reposCacheByName := make(map[string]int, len(repos))
+	for idx, repo := range repos {
+		reposCacheByName[repo.Name] = idx
+	}
+
 	// Commit our changes for the other threads to look at
 	this.reposMut.Lock()
 	this.reposCache = repos
+	this.reposCacheByName = reposCacheByName
 	this.reposAlphabeticalOrder = alphabeticalOrderIndexes
 	this.reposMut.Unlock()