2014-02-19 17:50:53 +08:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2022-11-28 02:20:29 +08:00
// SPDX-License-Identifier: MIT
2014-02-19 17:50:53 +08:00
2014-05-02 09:21:46 +08:00
package cmd
2014-02-19 17:50:53 +08:00
import (
2019-12-15 17:51:28 +08:00
"context"
2014-02-19 17:50:53 +08:00
"fmt"
2020-07-27 04:31:28 +08:00
"net"
2014-02-19 17:50:53 +08:00
"net/http"
2014-04-16 08:01:20 +08:00
"os"
2023-03-16 15:22:54 +08:00
"path/filepath"
"strconv"
2014-09-29 17:38:46 +08:00
"strings"
2014-02-19 17:50:53 +08:00
2021-11-17 20:34:35 +08:00
_ "net/http/pprof" // Used for debugging if enabled and a web server is running
2023-07-21 20:14:20 +08:00
"code.gitea.io/gitea/modules/container"
2019-10-23 23:32:19 +08:00
"code.gitea.io/gitea/modules/graceful"
2016-11-11 00:24:48 +08:00
"code.gitea.io/gitea/modules/log"
2022-04-01 01:01:43 +08:00
"code.gitea.io/gitea/modules/process"
2023-07-21 20:14:20 +08:00
"code.gitea.io/gitea/modules/public"
2016-11-11 00:24:48 +08:00
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/routers"
2021-06-09 07:33:54 +08:00
"code.gitea.io/gitea/routers/install"
2016-12-26 09:16:37 +08:00
2022-06-18 18:04:52 +08:00
"github.com/felixge/fgprof"
2023-07-21 17:28:19 +08:00
"github.com/urfave/cli/v2"
2014-02-19 17:50:53 +08:00
)
2023-03-16 15:22:54 +08:00
// PIDFile could be set from build tag
var PIDFile = "/run/gitea.pid"
2016-11-04 19:42:18 +08:00
// CmdWeb represents the available web sub-command.
2023-07-21 17:28:19 +08:00
var CmdWeb = & cli . Command {
2014-02-19 17:50:53 +08:00
Name : "web" ,
2016-12-21 20:13:17 +08:00
Usage : "Start Gitea web server" ,
Description : ` Gitea web server is the only thing you need to run ,
2014-03-24 19:36:38 +08:00
and it takes care of all the other things for you ` ,
2023-06-28 14:02:06 +08:00
Before : PrepareConsoleLoggerLevel ( log . INFO ) ,
2014-02-19 17:50:53 +08:00
Action : runWeb ,
2015-02-02 01:41:03 +08:00
Flags : [ ] cli . Flag {
2023-07-21 17:28:19 +08:00
& cli . StringFlag {
Name : "port" ,
Aliases : [ ] string { "p" } ,
Value : "3000" ,
Usage : "Temporary port number to prevent conflict" ,
2016-11-10 06:18:22 +08:00
} ,
2023-07-21 17:28:19 +08:00
& cli . StringFlag {
2020-10-31 03:26:03 +08:00
Name : "install-port" ,
Value : "3000" ,
Usage : "Temporary port number to run the install page on to prevent conflict" ,
} ,
2023-07-21 17:28:19 +08:00
& cli . StringFlag {
Name : "pid" ,
Aliases : [ ] string { "P" } ,
Value : PIDFile ,
Usage : "Custom pid file path" ,
2017-01-09 19:54:57 +08:00
} ,
2023-07-21 17:28:19 +08:00
& cli . BoolFlag {
Name : "quiet" ,
Aliases : [ ] string { "q" } ,
Usage : "Only display Fatal logging errors until logging is set-up" ,
2021-06-27 08:56:58 +08:00
} ,
2023-07-21 17:28:19 +08:00
& cli . BoolFlag {
2021-06-27 08:56:58 +08:00
Name : "verbose" ,
Usage : "Set initial logging to TRACE level until logging is properly set-up" ,
} ,
2015-02-02 01:41:03 +08:00
} ,
2014-02-19 17:50:53 +08:00
}
2017-12-26 06:23:43 +08:00
func runHTTPRedirector ( ) {
2022-04-01 01:01:43 +08:00
_ , _ , finished := process . GetManager ( ) . AddTypedContext ( graceful . GetManager ( ) . HammerContext ( ) , "Web: HTTP Redirector" , process . SystemProcessType , true )
defer finished ( )
2017-12-26 06:23:43 +08:00
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 )
} )
2022-08-22 02:20:43 +08:00
err := runHTTP ( "tcp" , source , "HTTP Redirector" , handler , setting . RedirectorUseProxyProtocol )
2017-12-26 06:23:43 +08:00
if err != nil {
2019-04-02 15:48:31 +08:00
log . Fatal ( "Failed to start port redirection: %v" , err )
2017-12-26 06:23:43 +08:00
}
}
2023-03-16 15:22:54 +08:00
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 )
}
}
2023-08-05 21:24:49 +08:00
func showWebStartupMessage ( msg string ) {
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
log . Info ( "Gitea version: %s%s" , setting . AppVer , setting . AppBuiltWith )
2023-08-05 21:24:49 +08:00
log . Info ( "* RunMode: %s" , setting . RunMode )
log . Info ( "* AppPath: %s" , setting . AppPath )
log . Info ( "* WorkPath: %s" , setting . AppWorkPath )
log . Info ( "* CustomPath: %s" , setting . CustomPath )
log . Info ( "* ConfigFile: %s" , setting . CustomConf )
log . Info ( "%s" , msg )
}
func serveInstall ( ctx * cli . Context ) error {
showWebStartupMessage ( "Prepare to run install page" )
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
routers . InitWebInstallPage ( graceful . GetManager ( ) . HammerContext ( ) )
// 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
}
}
c := install . Routes ( )
err := listen ( c , false )
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 :
}
return nil
}
func serveInstalled ( ctx * cli . Context ) error {
setting . InitCfgProvider ( setting . CustomConf )
setting . LoadCommonSettings ( )
setting . MustInstalled ( )
2023-08-05 21:24:49 +08:00
showWebStartupMessage ( "Prepare to run web server" )
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
if setting . AppWorkPathMismatch {
log . Error ( "WORK_PATH from config %q doesn't match other paths from environment variables or command arguments. " +
2023-08-05 21:24:49 +08:00
"Only WORK_PATH in config should be set and used. Please make sure the path in config file is correct, " +
"remove the other outdated work paths from environment variables and command arguments" , setting . CustomConf )
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
}
rootCfg := setting . CfgProvider
if rootCfg . Section ( "" ) . Key ( "WORK_PATH" ) . String ( ) == "" {
saveCfg , err := rootCfg . PrepareSaving ( )
if err != nil {
2023-08-05 21:24:49 +08:00
log . Error ( "Unable to prepare saving WORK_PATH=%s to config %q: %v\nYou should set it manually, otherwise there might be bugs when accessing the git repositories." , setting . AppWorkPath , setting . CustomConf , err )
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
} else {
rootCfg . Section ( "" ) . Key ( "WORK_PATH" ) . SetValue ( setting . AppWorkPath )
saveCfg . Section ( "" ) . Key ( "WORK_PATH" ) . SetValue ( setting . AppWorkPath )
if err = saveCfg . Save ( ) ; err != nil {
2023-08-05 21:24:49 +08:00
log . Error ( "Unable to update WORK_PATH=%s to config %q: %v\nYou should set it manually, otherwise there might be bugs when accessing the git repositories." , setting . AppWorkPath , setting . CustomConf , err )
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
}
}
}
2023-07-21 20:14:20 +08:00
// in old versions, user's custom web files are placed in "custom/public", and they were served as "http://domain.com/assets/xxx"
// now, Gitea only serves pre-defined files in the "custom/public" folder basing on the web root, the user should move their custom files to "custom/public/assets"
publicFiles , _ := public . AssetFS ( ) . ListFiles ( "." )
publicFilesSet := container . SetOf ( publicFiles ... )
publicFilesSet . Remove ( ".well-known" )
publicFilesSet . Remove ( "assets" )
publicFilesSet . Remove ( "robots.txt" )
for _ , fn := range publicFilesSet . Values ( ) {
log . Error ( "Found legacy public asset %q in CustomPath. Please move it to %s/public/assets/%s" , fn , setting . CustomPath , fn )
}
if _ , err := os . Stat ( filepath . Join ( setting . CustomPath , "robots.txt" ) ) ; err == nil {
log . Error ( ` Found legacy public asset "robots.txt" in CustomPath. Please move it to %s/public/robots.txt ` , setting . CustomPath )
}
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
routers . InitWebInstalled ( graceful . GetManager ( ) . HammerContext ( ) )
// We check that AppDataPath exists here (it should have been created during installation)
// We can't check it in `InitWebInstalled`, because some integration tests
// use cmd -> InitWebInstalled, 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 %q" , 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 ( )
err := listen ( c , true )
<- graceful . GetManager ( ) . Done ( )
log . Info ( "PID: %d Gitea Web Finished" , os . Getpid ( ) )
log . GetManager ( ) . Close ( )
return err
}
func servePprof ( ) {
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 ( )
}
2016-05-13 02:32:28 +08:00
func runWeb ( ctx * cli . Context ) error {
2021-08-24 03:40:59 +08:00
defer func ( ) {
if panicked := recover ( ) ; panicked != nil {
2022-01-20 19:41:25 +08:00
log . Fatal ( "PANIC: %v\n%s" , panicked , log . Stack ( 2 ) )
2021-08-24 03:40:59 +08:00
}
} ( )
2021-06-27 08:56:58 +08:00
2019-12-15 17:51:28 +08:00
managerCtx , cancel := context . WithCancel ( context . Background ( ) )
graceful . InitManager ( managerCtx )
defer cancel ( )
2019-10-15 21:39:51 +08:00
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
2017-01-09 19:54:57 +08:00
if ctx . IsSet ( "pid" ) {
2023-03-16 15:22:54 +08:00
createPIDFile ( ctx . String ( "pid" ) )
2017-01-09 19:54:57 +08:00
}
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
if ! setting . InstallLock {
if err := serveInstall ( ctx ) ; err != nil {
2020-10-20 05:03:08 +08:00
return err
}
} else {
NoInstallListener ( )
}
if setting . EnablePprof {
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
go servePprof ( )
2020-10-20 05:03:08 +08:00
}
Refactor path & config system (#25330)
# The problem
There were many "path tricks":
* By default, Gitea uses its program directory as its work path
* Gitea tries to use the "work path" to guess its "custom path" and
"custom conf (app.ini)"
* Users might want to use other directories as work path
* The non-default work path should be passed to Gitea by GITEA_WORK_DIR
or "--work-path"
* But some Gitea processes are started without these values
* The "serv" process started by OpenSSH server
* The CLI sub-commands started by site admin
* The paths are guessed by SetCustomPathAndConf again and again
* The default values of "work path / custom path / custom conf" can be
changed when compiling
# The solution
* Use `InitWorkPathAndCommonConfig` to handle these path tricks, and use
test code to cover its behaviors.
* When Gitea's web server runs, write the WORK_PATH to "app.ini", this
value must be the most correct one, because if this value is not right,
users would find that the web UI doesn't work and then they should be
able to fix it.
* Then all other sub-commands can use the WORK_PATH in app.ini to
initialize their paths.
* By the way, when Gitea starts for git protocol, it shouldn't output
any log, otherwise the git protocol gets broken and client blocks
forever.
The "work path" priority is: WORK_PATH in app.ini > cmd arg --work-path
> env var GITEA_WORK_DIR > builtin default
The "app.ini" searching order is: cmd arg --config > cmd arg "work path
/ custom path" > env var "work path / custom path" > builtin default
## ⚠️ BREAKING
If your instance's "work path / custom path / custom conf" doesn't meet
the requirements (eg: work path must be absolute), Gitea will report a
fatal error and exit. You need to set these values according to the
error log.
----
Close #24818
Close #24222
Close #21606
Close #21498
Close #25107
Close #24981
Maybe close #24503
Replace #23301
Replace #22754
And maybe more
2023-06-21 13:50:26 +08:00
return serveInstalled ( ctx )
2020-10-20 05:03:08 +08:00
}
2017-12-13 16:57:28 +08:00
2020-10-20 05:03:08 +08:00
func setPort ( port string ) error {
setting . AppURL = strings . Replace ( setting . AppURL , setting . HTTPPort , port , 1 )
setting . HTTPPort = port
2017-12-13 16:57:28 +08:00
2020-10-20 05:03:08 +08:00
switch setting . Protocol {
2021-12-06 12:46:11 +08:00
case setting . HTTPUnix :
2020-10-20 05:03:08 +08:00
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 + "/"
2017-12-13 16:57:28 +08:00
2021-05-30 02:44:14 +08:00
// Save LOCAL_ROOT_URL if port changed
2023-06-21 10:31:40 +08:00
rootCfg := setting . CfgProvider
saveCfg , err := rootCfg . PrepareSaving ( )
if err != nil {
return fmt . Errorf ( "failed to save config file: %v" , err )
}
rootCfg . Section ( "server" ) . Key ( "LOCAL_ROOT_URL" ) . SetValue ( defaultLocalURL )
saveCfg . Section ( "server" ) . Key ( "LOCAL_ROOT_URL" ) . SetValue ( defaultLocalURL )
if err = saveCfg . Save ( ) ; err != nil {
return fmt . Errorf ( "failed to save config file: %v" , err )
2023-04-25 23:06:39 +08:00
}
2015-02-02 01:41:03 +08:00
}
2020-10-20 05:03:08 +08:00
return nil
}
2015-02-02 01:41:03 +08:00
2020-11-13 20:51:07 +08:00
func listen ( m http . Handler , handleRedirector bool ) error {
2018-01-13 06:16:49 +08:00
listenAddr := setting . HTTPAddr
2021-12-06 12:46:11 +08:00
if setting . Protocol != setting . HTTPUnix && setting . Protocol != setting . FCGIUnix {
2020-07-27 04:31:28 +08:00
listenAddr = net . JoinHostPort ( listenAddr , setting . HTTPPort )
2016-08-12 05:46:33 +08:00
}
2022-04-01 01:01:43 +08:00
_ , _ , finished := process . GetManager ( ) . AddTypedContext ( graceful . GetManager ( ) . HammerContext ( ) , "Web: Gitea Server" , process . SystemProcessType , true )
defer finished ( )
2016-11-27 18:14:25 +08:00
log . Info ( "Listen: %v://%s%s" , setting . Protocol , listenAddr , setting . AppSubURL )
2021-11-01 16:39:52 +08:00
// 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 )
2016-08-12 05:55:10 +08:00
2016-12-26 09:16:37 +08:00
if setting . LFS . StartServer {
log . Info ( "LFS server enabled" )
}
2016-08-12 05:55:10 +08:00
var err error
2014-05-26 08:11:25 +08:00
switch setting . Protocol {
case setting . HTTP :
2020-10-20 05:03:08 +08:00
if handleRedirector {
NoHTTPRedirector ( )
}
2022-08-22 02:20:43 +08:00
err = runHTTP ( "tcp" , listenAddr , "Web" , m , setting . UseProxyProtocol )
2014-05-26 08:11:25 +08:00
case setting . HTTPS :
2022-02-08 13:45:35 +08:00
if setting . EnableAcme {
err = runACME ( listenAddr , m )
2018-08-21 21:56:50 +08:00
break
2022-08-22 02:20:43 +08:00
}
if handleRedirector {
if setting . RedirectOtherPort {
go runHTTPRedirector ( )
} else {
NoHTTPRedirector ( )
2020-10-20 05:03:08 +08:00
}
2017-12-26 06:23:43 +08:00
}
2022-08-22 02:20:43 +08:00
err = runHTTPS ( "tcp" , listenAddr , "Web" , setting . CertFile , setting . KeyFile , m , setting . UseProxyProtocol , setting . ProxyProtocolTLSBridging )
2014-11-04 09:46:53 +08:00
case setting . FCGI :
2020-10-20 05:03:08 +08:00
if handleRedirector {
NoHTTPRedirector ( )
}
2022-08-22 02:20:43 +08:00
err = runFCGI ( "tcp" , listenAddr , "FCGI Web" , m , setting . UseProxyProtocol )
2021-12-06 12:46:11 +08:00
case setting . HTTPUnix :
2020-10-20 05:03:08 +08:00
if handleRedirector {
NoHTTPRedirector ( )
}
2022-08-22 02:20:43 +08:00
err = runHTTP ( "unix" , listenAddr , "Web" , m , setting . UseProxyProtocol )
2019-12-10 20:23:26 +08:00
case setting . FCGIUnix :
2020-10-20 05:03:08 +08:00
if handleRedirector {
NoHTTPRedirector ( )
}
2022-08-22 02:20:43 +08:00
err = runFCGI ( "unix" , listenAddr , "Web" , m , setting . UseProxyProtocol )
2014-05-26 08:11:25 +08:00
default :
2019-04-02 15:48:31 +08:00
log . Fatal ( "Invalid protocol: %s" , setting . Protocol )
2014-05-26 08:11:25 +08:00
}
if err != nil {
2019-10-15 21:39:51 +08:00
log . Critical ( "Failed to start server: %v" , err )
2014-03-18 21:58:58 +08:00
}
2019-10-15 21:39:51 +08:00
log . Info ( "HTTP Listener: %s Closed" , listenAddr )
2020-10-20 05:03:08 +08:00
return err
2014-02-19 17:50:53 +08:00
}