mirror of
https://codeberg.org/forgejo/forgejo.git
synced 2024-12-23 07:43:18 -05:00
4647660776
## ⚠️ Breaking The `log.<mode>.<logger>` style config has been dropped. If you used it, please check the new config manual & app.example.ini to make your instance output logs as expected. Although many legacy options still work, it's encouraged to upgrade to the new options. The SMTP logger is deleted because SMTP is not suitable to collect logs. If you have manually configured Gitea log options, please confirm the logger system works as expected after upgrading. ## Description Close #12082 and maybe more log-related issues, resolve some related FIXMEs in old code (which seems unfixable before) Just like rewriting queue #24505 : make code maintainable, clear legacy bugs, and add the ability to support more writers (eg: JSON, structured log) There is a new document (with examples): `logging-config.en-us.md` This PR is safer than the queue rewriting, because it's just for logging, it won't break other logic. ## The old problems The logging system is quite old and difficult to maintain: * Unclear concepts: Logger, NamedLogger, MultiChannelledLogger, SubLogger, EventLogger, WriterLogger etc * Some code is diffuclt to konw whether it is right: `log.DelNamedLogger("console")` vs `log.DelNamedLogger(log.DEFAULT)` vs `log.DelLogger("console")` * The old system heavily depends on ini config system, it's difficult to create new logger for different purpose, and it's very fragile. * The "color" trick is difficult to use and read, many colors are unnecessary, and in the future structured log could help * It's difficult to add other log formats, eg: JSON format * The log outputer doesn't have full control of its goroutine, it's difficult to make outputer have advanced behaviors * The logs could be lost in some cases: eg: no Fatal error when using CLI. * Config options are passed by JSON, which is quite fragile. * INI package makes the KEY in `[log]` section visible in `[log.sub1]` and `[log.sub1.subA]`, this behavior is quite fragile and would cause more unclear problems, and there is no strong requirement to support `log.<mode>.<logger>` syntax. ## The new design See `logger.go` for documents. ## Screenshot <details> ![image](https://github.com/go-gitea/gitea/assets/2114189/4462d713-ba39-41f5-bb08-de912e67e1ff) ![image](https://github.com/go-gitea/gitea/assets/2114189/b188035e-f691-428b-8b2d-ff7b2199b2f9) ![image](https://github.com/go-gitea/gitea/assets/2114189/132e9745-1c3b-4e00-9e0d-15eaea495dee) </details> ## TODO * [x] add some new tests * [x] fix some tests * [x] test some sub-commands (manually ....) --------- Co-authored-by: Jason Song <i@wolfogre.com> Co-authored-by: delvh <dev.lh@web.de> Co-authored-by: Giteabot <teabot@gitea.io>
290 lines
8.6 KiB
Go
290 lines
8.6 KiB
Go
// Copyright 2014 The Gogs Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
|
|
_ "net/http/pprof" // Used for debugging if enabled and a web server is running
|
|
|
|
"code.gitea.io/gitea/modules/graceful"
|
|
"code.gitea.io/gitea/modules/log"
|
|
"code.gitea.io/gitea/modules/process"
|
|
"code.gitea.io/gitea/modules/setting"
|
|
"code.gitea.io/gitea/routers"
|
|
"code.gitea.io/gitea/routers/install"
|
|
|
|
"github.com/felixge/fgprof"
|
|
"github.com/urfave/cli"
|
|
)
|
|
|
|
// PIDFile could be set from build tag
|
|
var PIDFile = "/run/gitea.pid"
|
|
|
|
// CmdWeb represents the available web sub-command.
|
|
var CmdWeb = cli.Command{
|
|
Name: "web",
|
|
Usage: "Start Gitea web server",
|
|
Description: `Gitea web server is the only thing you need to run,
|
|
and it takes care of all the other things for you`,
|
|
Action: runWeb,
|
|
Flags: []cli.Flag{
|
|
cli.StringFlag{
|
|
Name: "port, p",
|
|
Value: "3000",
|
|
Usage: "Temporary port number to prevent conflict",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "install-port",
|
|
Value: "3000",
|
|
Usage: "Temporary port number to run the install page on to prevent conflict",
|
|
},
|
|
cli.StringFlag{
|
|
Name: "pid, P",
|
|
Value: PIDFile,
|
|
Usage: "Custom pid file path",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "quiet, q",
|
|
Usage: "Only display Fatal logging errors until logging is set-up",
|
|
},
|
|
cli.BoolFlag{
|
|
Name: "verbose",
|
|
Usage: "Set initial logging to TRACE level until logging is properly set-up",
|
|
},
|
|
},
|
|
}
|
|
|
|
func runHTTPRedirector() {
|
|
_, _, finished := process.GetManager().AddTypedContext(graceful.GetManager().HammerContext(), "Web: HTTP Redirector", process.SystemProcessType, true)
|
|
defer finished()
|
|
|
|
source := fmt.Sprintf("%s:%s", setting.HTTPAddr, setting.PortToRedirect)
|
|
dest := strings.TrimSuffix(setting.AppURL, "/")
|
|
log.Info("Redirecting: %s to %s", source, dest)
|
|
|
|
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
target := dest + r.URL.Path
|
|
if len(r.URL.RawQuery) > 0 {
|
|
target += "?" + r.URL.RawQuery
|
|
}
|
|
http.Redirect(w, r, target, http.StatusTemporaryRedirect)
|
|
})
|
|
|
|
err := runHTTP("tcp", source, "HTTP Redirector", handler, setting.RedirectorUseProxyProtocol)
|
|
if err != nil {
|
|
log.Fatal("Failed to start port redirection: %v", err)
|
|
}
|
|
}
|
|
|
|
func createPIDFile(pidPath string) {
|
|
currentPid := os.Getpid()
|
|
if err := os.MkdirAll(filepath.Dir(pidPath), os.ModePerm); err != nil {
|
|
log.Fatal("Failed to create PID folder: %v", err)
|
|
}
|
|
|
|
file, err := os.Create(pidPath)
|
|
if err != nil {
|
|
log.Fatal("Failed to create PID file: %v", err)
|
|
}
|
|
defer file.Close()
|
|
if _, err := file.WriteString(strconv.FormatInt(int64(currentPid), 10)); err != nil {
|
|
log.Fatal("Failed to write PID information: %v", err)
|
|
}
|
|
}
|
|
|
|
func runWeb(ctx *cli.Context) error {
|
|
if ctx.Bool("verbose") {
|
|
setupConsoleLogger(log.TRACE, log.CanColorStdout, os.Stdout)
|
|
} else if ctx.Bool("quiet") {
|
|
setupConsoleLogger(log.FATAL, log.CanColorStdout, os.Stdout)
|
|
}
|
|
defer func() {
|
|
if panicked := recover(); panicked != nil {
|
|
log.Fatal("PANIC: %v\n%s", panicked, log.Stack(2))
|
|
}
|
|
}()
|
|
|
|
managerCtx, cancel := context.WithCancel(context.Background())
|
|
graceful.InitManager(managerCtx)
|
|
defer cancel()
|
|
|
|
if os.Getppid() > 1 && len(os.Getenv("LISTEN_FDS")) > 0 {
|
|
log.Info("Restarting Gitea on PID: %d from parent PID: %d", os.Getpid(), os.Getppid())
|
|
} else {
|
|
log.Info("Starting Gitea on PID: %d", os.Getpid())
|
|
}
|
|
|
|
// Set pid file setting
|
|
if ctx.IsSet("pid") {
|
|
createPIDFile(ctx.String("pid"))
|
|
}
|
|
|
|
// Perform pre-initialization
|
|
needsInstall := install.PreloadSettings(graceful.GetManager().HammerContext())
|
|
if needsInstall {
|
|
// Flag for port number in case first time run conflict
|
|
if ctx.IsSet("port") {
|
|
if err := setPort(ctx.String("port")); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if ctx.IsSet("install-port") {
|
|
if err := setPort(ctx.String("install-port")); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
installCtx, cancel := context.WithCancel(graceful.GetManager().HammerContext())
|
|
c := install.Routes(installCtx)
|
|
err := listen(c, false)
|
|
cancel()
|
|
if err != nil {
|
|
log.Critical("Unable to open listener for installer. Is Gitea already running?")
|
|
graceful.GetManager().DoGracefulShutdown()
|
|
}
|
|
select {
|
|
case <-graceful.GetManager().IsShutdown():
|
|
<-graceful.GetManager().Done()
|
|
log.Info("PID: %d Gitea Web Finished", os.Getpid())
|
|
log.GetManager().Close()
|
|
return err
|
|
default:
|
|
}
|
|
} else {
|
|
NoInstallListener()
|
|
}
|
|
|
|
if setting.EnablePprof {
|
|
go func() {
|
|
http.DefaultServeMux.Handle("/debug/fgprof", fgprof.Handler())
|
|
_, _, finished := process.GetManager().AddTypedContext(context.Background(), "Web: PProf Server", process.SystemProcessType, true)
|
|
// The pprof server is for debug purpose only, it shouldn't be exposed on public network. At the moment it's not worth to introduce a configurable option for it.
|
|
log.Info("Starting pprof server on localhost:6060")
|
|
log.Info("Stopped pprof server: %v", http.ListenAndServe("localhost:6060", nil))
|
|
finished()
|
|
}()
|
|
}
|
|
|
|
log.Info("Global init")
|
|
// Perform global initialization
|
|
setting.Init(&setting.Options{})
|
|
routers.GlobalInitInstalled(graceful.GetManager().HammerContext())
|
|
|
|
// We check that AppDataPath exists here (it should have been created during installation)
|
|
// We can't check it in `GlobalInitInstalled`, because some integration tests
|
|
// use cmd -> GlobalInitInstalled, but the AppDataPath doesn't exist during those tests.
|
|
if _, err := os.Stat(setting.AppDataPath); err != nil {
|
|
log.Fatal("Can not find APP_DATA_PATH '%s'", setting.AppDataPath)
|
|
}
|
|
|
|
// Override the provided port number within the configuration
|
|
if ctx.IsSet("port") {
|
|
if err := setPort(ctx.String("port")); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// Set up Chi routes
|
|
c := routers.NormalRoutes(graceful.GetManager().HammerContext())
|
|
err := listen(c, true)
|
|
<-graceful.GetManager().Done()
|
|
log.Info("PID: %d Gitea Web Finished", os.Getpid())
|
|
log.GetManager().Close()
|
|
return err
|
|
}
|
|
|
|
func setPort(port string) error {
|
|
setting.AppURL = strings.Replace(setting.AppURL, setting.HTTPPort, port, 1)
|
|
setting.HTTPPort = port
|
|
|
|
switch setting.Protocol {
|
|
case setting.HTTPUnix:
|
|
case setting.FCGI:
|
|
case setting.FCGIUnix:
|
|
default:
|
|
defaultLocalURL := string(setting.Protocol) + "://"
|
|
if setting.HTTPAddr == "0.0.0.0" {
|
|
defaultLocalURL += "localhost"
|
|
} else {
|
|
defaultLocalURL += setting.HTTPAddr
|
|
}
|
|
defaultLocalURL += ":" + setting.HTTPPort + "/"
|
|
|
|
// Save LOCAL_ROOT_URL if port changed
|
|
setting.CfgProvider.Section("server").Key("LOCAL_ROOT_URL").SetValue(defaultLocalURL)
|
|
if err := setting.CfgProvider.Save(); err != nil {
|
|
return fmt.Errorf("Failed to save config file: %v", err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func listen(m http.Handler, handleRedirector bool) error {
|
|
listenAddr := setting.HTTPAddr
|
|
if setting.Protocol != setting.HTTPUnix && setting.Protocol != setting.FCGIUnix {
|
|
listenAddr = net.JoinHostPort(listenAddr, setting.HTTPPort)
|
|
}
|
|
_, _, finished := process.GetManager().AddTypedContext(graceful.GetManager().HammerContext(), "Web: Gitea Server", process.SystemProcessType, true)
|
|
defer finished()
|
|
log.Info("Listen: %v://%s%s", setting.Protocol, listenAddr, setting.AppSubURL)
|
|
// This can be useful for users, many users do wrong to their config and get strange behaviors behind a reverse-proxy.
|
|
// A user may fix the configuration mistake when he sees this log.
|
|
// And this is also very helpful to maintainers to provide help to users to resolve their configuration problems.
|
|
log.Info("AppURL(ROOT_URL): %s", setting.AppURL)
|
|
|
|
if setting.LFS.StartServer {
|
|
log.Info("LFS server enabled")
|
|
}
|
|
|
|
var err error
|
|
switch setting.Protocol {
|
|
case setting.HTTP:
|
|
if handleRedirector {
|
|
NoHTTPRedirector()
|
|
}
|
|
err = runHTTP("tcp", listenAddr, "Web", m, setting.UseProxyProtocol)
|
|
case setting.HTTPS:
|
|
if setting.EnableAcme {
|
|
err = runACME(listenAddr, m)
|
|
break
|
|
}
|
|
if handleRedirector {
|
|
if setting.RedirectOtherPort {
|
|
go runHTTPRedirector()
|
|
} else {
|
|
NoHTTPRedirector()
|
|
}
|
|
}
|
|
err = runHTTPS("tcp", listenAddr, "Web", setting.CertFile, setting.KeyFile, m, setting.UseProxyProtocol, setting.ProxyProtocolTLSBridging)
|
|
case setting.FCGI:
|
|
if handleRedirector {
|
|
NoHTTPRedirector()
|
|
}
|
|
err = runFCGI("tcp", listenAddr, "FCGI Web", m, setting.UseProxyProtocol)
|
|
case setting.HTTPUnix:
|
|
if handleRedirector {
|
|
NoHTTPRedirector()
|
|
}
|
|
err = runHTTP("unix", listenAddr, "Web", m, setting.UseProxyProtocol)
|
|
case setting.FCGIUnix:
|
|
if handleRedirector {
|
|
NoHTTPRedirector()
|
|
}
|
|
err = runFCGI("unix", listenAddr, "Web", m, setting.UseProxyProtocol)
|
|
default:
|
|
log.Fatal("Invalid protocol: %s", setting.Protocol)
|
|
}
|
|
if err != nil {
|
|
log.Critical("Failed to start server: %v", err)
|
|
}
|
|
log.Info("HTTP Listener: %s Closed", listenAddr)
|
|
return err
|
|
}
|