Refactor template render (#36438)

routers/common/errpage.go

@@ -4,8 +4,11 @@
 package common
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"net/http"
+	"strings"
 
 	user_model "code.gitea.io/gitea/models/user"
 	"code.gitea.io/gitea/modules/httpcache"
@@ -19,6 +22,36 @@ import (
 
 const tplStatus500 templates.TplName = "status/500"
 
+func renderServerErrorPage(w http.ResponseWriter, req *http.Request, respCode int, tmpl templates.TplName, ctxData map[string]any, plainMsg string) {
+	acceptsHTML := false
+	for _, part := range req.Header["Accept"] {
+		if strings.Contains(part, "text/html") {
+			acceptsHTML = true
+			break
+		}
+	}
+
+	httpcache.SetCacheControlInHeader(w.Header(), &httpcache.CacheControlOptions{NoTransform: true})
+	w.Header().Set(`X-Frame-Options`, setting.CORSConfig.XFrameOptions)
+
+	tmplCtx := context.NewTemplateContext(req.Context(), req)
+	tmplCtx["Locale"] = middleware.Locale(w, req)
+
+	w.WriteHeader(respCode)
+
+	outBuf := &bytes.Buffer{}
+	if acceptsHTML {
+		err := templates.PageRenderer().HTML(outBuf, respCode, tmpl, ctxData, tmplCtx)
+		if err != nil {
+			_, _ = w.Write([]byte("Internal server error but failed to render error page template, please collect error logs and report to Gitea issue tracker"))
+			return
+		}
+	} else {
+		outBuf.WriteString(plainMsg)
+	}
+	_, _ = io.Copy(w, outBuf)
+}
+
 // RenderPanicErrorPage renders a 500 page, and it never panics
 func RenderPanicErrorPage(w http.ResponseWriter, req *http.Request, err any) {
 	combinedErr := fmt.Sprintf("%v\n%s", err, log.Stack(2))
@@ -32,24 +65,14 @@ func RenderPanicErrorPage(w http.ResponseWriter, req *http.Request, err any) {
 
 	routing.UpdatePanicError(req.Context(), err)
 
-	httpcache.SetCacheControlInHeader(w.Header(), &httpcache.CacheControlOptions{NoTransform: true})
-	w.Header().Set(`X-Frame-Options`, setting.CORSConfig.XFrameOptions)
-
-	tmplCtx := context.NewTemplateContext(req.Context(), req)
-	tmplCtx["Locale"] = middleware.Locale(w, req)
+	plainMsg := "Internal Server Error"
 	ctxData := middleware.GetContextData(req.Context())
-
 	// This recovery handler could be called without Gitea's web context, so we shouldn't touch that context too much.
 	// Otherwise, the 500-page may cause new panics, eg: cache.GetContextWithData, it makes the developer&users couldn't find the original panic.
 	user, _ := ctxData[middleware.ContextDataKeySignedUser].(*user_model.User)
 	if !setting.IsProd || (user != nil && user.IsAdmin) {
-		ctxData["ErrorMsg"] = "PANIC: " + combinedErr
-	}
-
-	err = templates.HTMLRenderer().HTML(w, http.StatusInternalServerError, tplStatus500, ctxData, tmplCtx)
-	if err != nil {
-		log.Error("Error occurs again when rendering error page: %v", err)
-		w.WriteHeader(http.StatusInternalServerError)
-		_, _ = w.Write([]byte("Internal server error, please collect error logs and report to Gitea issue tracker"))
+		plainMsg = "PANIC: " + combinedErr
+		ctxData["ErrorMsg"] = plainMsg
 	}
+	renderServerErrorPage(w, req, http.StatusInternalServerError, tplStatus500, ctxData, plainMsg)
 }

routers/common/errpage_test.go

@@ -18,19 +18,28 @@ import (
 )
 
 func TestRenderPanicErrorPage(t *testing.T) {
-	w := httptest.NewRecorder()
-	req := &http.Request{URL: &url.URL{}}
-	req = req.WithContext(reqctx.NewRequestContextForTest(t.Context()))
-	RenderPanicErrorPage(w, req, errors.New("fake panic error (for test only)"))
-	respContent := w.Body.String()
-	assert.Contains(t, respContent, `class="page-content status-page-500"`)
-	assert.Contains(t, respContent, `</html>`)
-	assert.Contains(t, respContent, `lang="en-US"`) // make sure the locale work
+	t.Run("HTML", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		req := &http.Request{URL: &url.URL{}, Header: http.Header{"Accept": []string{"text/html"}}}
+		req = req.WithContext(reqctx.NewRequestContextForTest(t.Context()))
+		RenderPanicErrorPage(w, req, errors.New("fake panic error (for test only)"))
+		respContent := w.Body.String()
+		assert.Contains(t, respContent, `class="page-content status-page-500"`)
+		assert.Contains(t, respContent, `</html>`)
+		assert.Contains(t, respContent, `lang="en-US"`) // make sure the locale work
 
-	// the 500 page doesn't have normal pages footer, it makes it easier to distinguish a normal page and a failed page.
-	// especially when a sub-template causes page error, the HTTP response code is still 200,
-	// the different "footer" is the only way to know whether a page is fully rendered without error.
-	assert.False(t, test.IsNormalPageCompleted(respContent))
+		// the 500 page doesn't have normal pages footer, it makes it easier to distinguish a normal page and a failed page.
+		// especially when a sub-template causes page error, the HTTP response code is still 200,
+		// the different "footer" is the only way to know whether a page is fully rendered without error.
+		assert.False(t, test.IsNormalPageCompleted(respContent))
+	})
+	t.Run("Plain", func(t *testing.T) {
+		w := httptest.NewRecorder()
+		req := &http.Request{URL: &url.URL{}}
+		req = req.WithContext(reqctx.NewRequestContextForTest(t.Context()))
+		renderServiceUnavailable(w, req)
+		assert.Equal(t, "Service Unavailable", w.Body.String())
+	})
 }
 
 func TestMain(m *testing.M) {

routers/common/qos.go

@@ -14,7 +14,6 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/templates"
 	"code.gitea.io/gitea/modules/web/middleware"
-	giteacontext "code.gitea.io/gitea/services/context"
 
 	"github.com/bohde/codel"
 	"github.com/go-chi/chi/v5"
@@ -119,27 +118,6 @@ func requestPriority(ctx context.Context) Priority {
 // renderServiceUnavailable will render an HTTP 503 Service
 // Unavailable page, providing HTML if the client accepts it.
 func renderServiceUnavailable(w http.ResponseWriter, req *http.Request) {
-	acceptsHTML := false
-	for _, part := range req.Header["Accept"] {
-		if strings.Contains(part, "text/html") {
-			acceptsHTML = true
-			break
-		}
-	}
-
-	// If the client doesn't accept HTML, then render a plain text response
-	if !acceptsHTML {
-		http.Error(w, "503 Service Unavailable", http.StatusServiceUnavailable)
-		return
-	}
-
-	tmplCtx := giteacontext.NewTemplateContext(req.Context(), req)
-	tmplCtx["Locale"] = middleware.Locale(w, req)
 	ctxData := middleware.GetContextData(req.Context())
-	err := templates.HTMLRenderer().HTML(w, http.StatusServiceUnavailable, tplStatus503, ctxData, tmplCtx)
-	if err != nil {
-		log.Error("Error occurs again when rendering service unavailable page: %v", err)
-		w.WriteHeader(http.StatusInternalServerError)
-		_, _ = w.Write([]byte("Internal server error, please collect error logs and report to Gitea issue tracker"))
-	}
+	renderServerErrorPage(w, req, http.StatusServiceUnavailable, tplStatus503, ctxData, "Service Unavailable")
 }

routers/common/qos_test.go

@@ -4,7 +4,6 @@
 package common
 
 import (
-	"net/http"
 	"testing"
 
 	user_model "code.gitea.io/gitea/models/user"
@@ -62,30 +61,3 @@ func TestRequestPriority(t *testing.T) {
 		})
 	}
 }
-
-func TestRenderServiceUnavailable(t *testing.T) {
-	t.Run("HTML", func(t *testing.T) {
-		ctx, resp := contexttest.MockContext(t, "")
-		ctx.Req.Header.Set("Accept", "text/html")
-
-		renderServiceUnavailable(resp, ctx.Req)
-		assert.Equal(t, http.StatusServiceUnavailable, resp.Code)
-		assert.Contains(t, resp.Header().Get("Content-Type"), "text/html")
-
-		body := resp.Body.String()
-		assert.Contains(t, body, `lang="en-US"`)
-		assert.Contains(t, body, "503 Service Unavailable")
-	})
-
-	t.Run("plain", func(t *testing.T) {
-		ctx, resp := contexttest.MockContext(t, "")
-		ctx.Req.Header.Set("Accept", "text/plain")
-
-		renderServiceUnavailable(resp, ctx.Req)
-		assert.Equal(t, http.StatusServiceUnavailable, resp.Code)
-		assert.Contains(t, resp.Header().Get("Content-Type"), "text/plain")
-
-		body := resp.Body.String()
-		assert.Contains(t, body, "503 Service Unavailable")
-	})
-}

routers/init.go

@@ -24,7 +24,6 @@ import (
 	"code.gitea.io/gitea/modules/storage"
 	"code.gitea.io/gitea/modules/svg"
 	"code.gitea.io/gitea/modules/system"
-	"code.gitea.io/gitea/modules/templates"
 	"code.gitea.io/gitea/modules/translation"
 	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/modules/web"
@@ -182,7 +181,6 @@ func InitWebInstalled(ctx context.Context) {
 
 // NormalRoutes represents non install routes
 func NormalRoutes() *web.Router {
-	_ = templates.HTMLRenderer()
 	r := web.NewRouter()
 	r.Use(common.ProtocolMiddlewares()...)
 

routers/install/install.go

@@ -24,11 +24,9 @@ import (
 	"code.gitea.io/gitea/modules/graceful"
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/optional"
-	"code.gitea.io/gitea/modules/reqctx"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/templates"
 	"code.gitea.io/gitea/modules/timeutil"
-	"code.gitea.io/gitea/modules/translation"
 	"code.gitea.io/gitea/modules/user"
 	"code.gitea.io/gitea/modules/web"
 	"code.gitea.io/gitea/modules/web/middleware"
@@ -37,8 +35,6 @@ import (
 	"code.gitea.io/gitea/services/context"
 	"code.gitea.io/gitea/services/forms"
 	"code.gitea.io/gitea/services/versioned_migration"
-
-	"gitea.com/go-chi/session"
 )
 
 const (
@@ -55,29 +51,13 @@ func getSupportedDbTypeNames() (dbTypeNames []map[string]string) {
 	return dbTypeNames
 }
 
-// installContexter prepare for rendering installation page
 func installContexter() func(next http.Handler) http.Handler {
-	rnd := templates.HTMLRenderer()
-	dbTypeNames := getSupportedDbTypeNames()
-	envConfigKeys := setting.CollectEnvConfigKeys()
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-			base := context.NewBaseContext(resp, req)
-			ctx := context.NewWebContext(base, rnd, session.GetSession(req))
-			ctx.Data.MergeFrom(middleware.CommonTemplateContextData())
-			ctx.Data.MergeFrom(reqctx.ContextData{
-				"Title":          ctx.Locale.Tr("install.install"),
-				"PageIsInstall":  true,
-				"DbTypeNames":    dbTypeNames,
-				"EnvConfigKeys":  envConfigKeys,
-				"CustomConfFile": setting.CustomConf,
-				"AllLangs":       translation.AllLangs(),
-
-				"PasswordHashAlgorithms": hash.RecommendedHashAlgorithms,
-			})
-			next.ServeHTTP(resp, ctx.Req)
-		})
-	}
+	return context.ContexterInstallPage(map[string]any{
+		"DbTypeNames":            getSupportedDbTypeNames(),
+		"EnvConfigKeys":          setting.CollectEnvConfigKeys(),
+		"CustomConfFile":         setting.CustomConf,
+		"PasswordHashAlgorithms": hash.RecommendedHashAlgorithms,
+	})
 }
 
 // Install render installation page

routers/private/manager.go

@@ -21,7 +21,7 @@ import (
 
 // ReloadTemplates reloads all the templates
 func ReloadTemplates(ctx *context.PrivateContext) {
-	err := templates.ReloadHTMLTemplates()
+	err := templates.ReloadAllTemplates()
 	if err != nil {
 		ctx.JSON(http.StatusInternalServerError, private.Response{
 			UserMsg: fmt.Sprintf("Template error: %v", err),

routers/web/devtest/mail_preview.go

@@ -8,6 +8,7 @@ import (
 	"strings"
 
 	"code.gitea.io/gitea/modules/templates"
+	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/services/context"
 	"code.gitea.io/gitea/services/mailer"
 
@@ -34,17 +35,18 @@ func MailPreviewRender(ctx *context.Context) {
 
 func prepareMailPreviewRender(ctx *context.Context, tmplName string) {
 	tmplSubject := mailer.LoadedTemplates().SubjectTemplates.Lookup(tmplName)
-	if tmplSubject == nil {
-		ctx.Data["RenderMailSubject"] = "default subject"
-	} else {
+	// FIXME: MAIL-TEMPLATE-SUBJECT: only "issue" related messages support using subject from templates
+	subject := "(default subject)"
+	if tmplSubject != nil {
 		var buf strings.Builder
 		err := tmplSubject.Execute(&buf, nil)
 		if err != nil {
-			ctx.Data["RenderMailSubject"] = err.Error()
+			subject = "ERROR: " + err.Error()
 		} else {
-			ctx.Data["RenderMailSubject"] = buf.String()
+			subject = util.IfZero(buf.String(), subject)
 		}
 	}
+	ctx.Data["RenderMailSubject"] = subject
 	ctx.Data["RenderMailTemplateName"] = tmplName
 }
 

routers/web/repo/pull_review_test.go

@@ -30,7 +30,7 @@ func TestRenderConversation(t *testing.T) {
 
 	run := func(name string, cb func(t *testing.T, ctx *context.Context, resp *httptest.ResponseRecorder)) {
 		t.Run(name, func(t *testing.T) {
-			ctx, resp := contexttest.MockContext(t, "/", contexttest.MockContextOption{Render: templates.HTMLRenderer()})
+			ctx, resp := contexttest.MockContext(t, "/", contexttest.MockContextOption{Render: templates.PageRenderer()})
 			contexttest.LoadUser(t, ctx, pr.Issue.PosterID)
 			contexttest.LoadRepo(t, ctx, pr.BaseRepoID)
 			contexttest.LoadGitRepo(t, ctx)

routers/web/user/home_test.go

@@ -116,7 +116,7 @@ func TestMilestonesForSpecificRepo(t *testing.T) {
 }
 
 func TestDashboardPagination(t *testing.T) {
-	ctx, _ := contexttest.MockContext(t, "/", contexttest.MockContextOption{Render: templates.HTMLRenderer()})
+	ctx, _ := contexttest.MockContext(t, "/", contexttest.MockContextOption{Render: templates.PageRenderer()})
 	page := context.NewPagination(10, 3, 1, 3)
 
 	setting.AppSubURL = "/SubPath"

routers/web/web.go

@@ -18,7 +18,6 @@ import (
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/storage"
 	"code.gitea.io/gitea/modules/structs"
-	"code.gitea.io/gitea/modules/templates"
 	"code.gitea.io/gitea/modules/validation"
 	"code.gitea.io/gitea/modules/web"
 	"code.gitea.io/gitea/modules/web/middleware"
@@ -232,8 +231,6 @@ func Routes() *web.Router {
 	routes.Methods("GET, HEAD", "/apple-touch-icon-precomposed.png", misc.StaticRedirect("/assets/img/apple-touch-icon.png"))
 	routes.Methods("GET, HEAD", "/favicon.ico", misc.StaticRedirect("/assets/img/favicon.png"))
 
-	_ = templates.HTMLRenderer()
-
 	var mid []any
 
 	if setting.EnableGzip {