Refactor routers directory (#15800)

* refactor routers directory

* move func used for web and api to common

* make corsHandler a function to prohibit side efects

* rm unused func

Co-authored-by: 6543 <6543@obermui.de>

routers/install/routes.go

@@ -0,0 +1,113 @@
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package install
+
+import (
+	"fmt"
+	"net/http"
+	"path"
+
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/public"
+	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/templates"
+	"code.gitea.io/gitea/modules/web"
+	"code.gitea.io/gitea/modules/web/middleware"
+	"code.gitea.io/gitea/routers/common"
+	"code.gitea.io/gitea/services/forms"
+
+	"gitea.com/go-chi/session"
+)
+
+type dataStore map[string]interface{}
+
+func (d *dataStore) GetData() map[string]interface{} {
+	return *d
+}
+
+func installRecovery() func(next http.Handler) http.Handler {
+	var rnd = templates.HTMLRenderer()
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+			defer func() {
+				// Why we need this? The first recover will try to render a beautiful
+				// error page for user, but the process can still panic again, then
+				// we have to just recover twice and send a simple error page that
+				// should not panic any more.
+				defer func() {
+					if err := recover(); err != nil {
+						combinedErr := fmt.Sprintf("PANIC: %v\n%s", err, string(log.Stack(2)))
+						log.Error(combinedErr)
+						if setting.IsProd() {
+							http.Error(w, http.StatusText(500), 500)
+						} else {
+							http.Error(w, combinedErr, 500)
+						}
+					}
+				}()
+
+				if err := recover(); err != nil {
+					combinedErr := fmt.Sprintf("PANIC: %v\n%s", err, string(log.Stack(2)))
+					log.Error("%v", combinedErr)
+
+					lc := middleware.Locale(w, req)
+					var store = dataStore{
+						"Language":       lc.Language(),
+						"CurrentURL":     setting.AppSubURL + req.URL.RequestURI(),
+						"i18n":           lc,
+						"SignedUserID":   int64(0),
+						"SignedUserName": "",
+					}
+
+					w.Header().Set(`X-Frame-Options`, `SAMEORIGIN`)
+
+					if !setting.IsProd() {
+						store["ErrorMsg"] = combinedErr
+					}
+					err = rnd.HTML(w, 500, "status/500", templates.BaseVars().Merge(store))
+					if err != nil {
+						log.Error("%v", err)
+					}
+				}
+			}()
+
+			next.ServeHTTP(w, req)
+		})
+	}
+}
+
+// Routes registers the install routes
+func Routes() *web.Route {
+	r := web.NewRoute()
+	for _, middle := range common.Middlewares() {
+		r.Use(middle)
+	}
+
+	r.Use(public.AssetsHandler(&public.Options{
+		Directory: path.Join(setting.StaticRootPath, "public"),
+		Prefix:    "/assets",
+	}))
+
+	r.Use(session.Sessioner(session.Options{
+		Provider:       setting.SessionConfig.Provider,
+		ProviderConfig: setting.SessionConfig.ProviderConfig,
+		CookieName:     setting.SessionConfig.CookieName,
+		CookiePath:     setting.SessionConfig.CookiePath,
+		Gclifetime:     setting.SessionConfig.Gclifetime,
+		Maxlifetime:    setting.SessionConfig.Maxlifetime,
+		Secure:         setting.SessionConfig.Secure,
+		SameSite:       setting.SessionConfig.SameSite,
+		Domain:         setting.SessionConfig.Domain,
+	}))
+
+	r.Use(installRecovery())
+	r.Use(Init)
+	r.Get("/", Install)
+	r.Post("/", web.Bind(forms.InstallForm{}), SubmitInstall)
+	r.NotFound(func(w http.ResponseWriter, req *http.Request) {
+		http.Redirect(w, req, setting.AppURL, http.StatusFound)
+	})
+	return r
+}

routers/install/setting.go

@@ -0,0 +1,49 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package install
+
+import (
+	"context"
+
+	"code.gitea.io/gitea/modules/log"
+	"code.gitea.io/gitea/modules/setting"
+	"code.gitea.io/gitea/modules/svg"
+	"code.gitea.io/gitea/modules/translation"
+	"code.gitea.io/gitea/routers/common"
+)
+
+// PreloadSettings preloads the configuration to check if we need to run install
+func PreloadSettings(ctx context.Context) bool {
+	setting.NewContext()
+	if !setting.InstallLock {
+		log.Trace("AppPath: %s", setting.AppPath)
+		log.Trace("AppWorkPath: %s", setting.AppWorkPath)
+		log.Trace("Custom path: %s", setting.CustomPath)
+		log.Trace("Log path: %s", setting.LogRootPath)
+		log.Trace("Preparing to run install page")
+		translation.InitLocales()
+		if setting.EnableSQLite3 {
+			log.Info("SQLite3 Supported")
+		}
+		setting.InitDBConfig()
+		svg.Init()
+	}
+
+	return !setting.InstallLock
+}
+
+// ReloadSettings rereads the settings and starts up the database
+func ReloadSettings(ctx context.Context) {
+	setting.NewContext()
+	setting.InitDBConfig()
+	if setting.InstallLock {
+		if err := common.InitDBEngine(ctx); err == nil {
+			log.Info("ORM engine initialization successful!")
+		} else {
+			log.Fatal("ORM engine initialization failed: %v", err)
+		}
+		svg.Init()
+	}
+}