2014-04-10 13:20:58 -05:00
// Copyright 2014 The Gogs Authors. All rights reserved.
2017-05-29 02:17:15 -05:00
// Copyright 2017 The Gitea Authors. All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2014-04-10 13:20:58 -05:00
2014-05-25 19:11:25 -05:00
package setting
2014-04-10 13:20:58 -05:00
import (
2023-02-03 12:22:11 -05:00
"errors"
2019-04-02 02:48:31 -05:00
"fmt"
2014-04-10 13:20:58 -05:00
"os"
"os/exec"
"path"
"path/filepath"
2019-04-28 14:48:46 -05:00
"runtime"
2014-04-10 13:20:58 -05:00
"strings"
2014-07-24 15:31:59 -05:00
"time"
2014-04-10 13:20:58 -05:00
2023-02-20 00:20:30 -05:00
"code.gitea.io/gitea/modules/auth/password/hash"
2016-12-22 13:12:23 -05:00
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/user"
2014-04-10 13:20:58 -05:00
)
2016-11-27 05:14:25 -05:00
// settings
2014-04-10 13:20:58 -05:00
var (
2021-02-19 16:36:43 -05:00
// AppVer is the version of the current build of Gitea. It is set in main.go from main.Version.
AppVer string
2023-04-19 08:40:42 -05:00
// AppBuiltWith represents a human-readable version go runtime build version and build tags. (See main.go formatBuiltWith().)
2021-02-19 16:36:43 -05:00
AppBuiltWith string
// AppStartTime store time gitea has started
AppStartTime time . Time
2023-02-19 11:12:01 -05:00
2021-02-19 16:36:43 -05:00
// AppPath represents the path to the gitea binary
AppPath string
// AppWorkPath is the "working directory" of Gitea. It maps to the environment variable GITEA_WORK_DIR.
// If that is not set it is the default set here by the linker or failing that the directory of AppPath.
//
// AppWorkPath is used as the base path for several other paths.
AppWorkPath string
2015-03-23 09:19:19 -05:00
2023-04-19 08:40:42 -05:00
// Other global setting objects
2023-03-16 02:22:54 -05:00
CfgProvider ConfigProvider
CustomPath string // Custom directory path
CustomConf string
RunMode string
RunUser string
IsProd bool
IsWindows bool
2023-04-19 08:40:42 -05:00
// IsInTesting indicates whether the testing is running. A lot of unreliable code causes a lot of nonsense error logs during testing
// TODO: this is only a temporary solution, we should make the test code more reliable
IsInTesting = false
2014-04-10 13:20:58 -05:00
)
2017-11-03 03:56:20 -05:00
func getAppPath ( ) ( string , error ) {
var appPath string
var err error
if IsWindows && filepath . IsAbs ( os . Args [ 0 ] ) {
appPath = filepath . Clean ( os . Args [ 0 ] )
} else {
appPath , err = exec . LookPath ( os . Args [ 0 ] )
2017-09-12 07:27:44 -05:00
}
2017-11-03 03:56:20 -05:00
2022-12-14 01:15:11 -05:00
if err != nil {
2023-02-03 12:22:11 -05:00
if ! errors . Is ( err , exec . ErrDot ) {
2022-12-14 01:15:11 -05:00
return "" , err
}
appPath , err = filepath . Abs ( os . Args [ 0 ] )
}
2014-05-25 19:11:25 -05:00
if err != nil {
return "" , err
}
2017-11-03 03:56:20 -05:00
appPath , err = filepath . Abs ( appPath )
if err != nil {
return "" , err
}
// Note: we don't use path.Dir here because it does not handle case
// which path starts with two "/" in Windows: "//psf/Home/..."
2020-10-11 15:27:20 -05:00
return strings . ReplaceAll ( appPath , "\\" , "/" ) , err
2017-11-03 03:56:20 -05:00
}
func getWorkPath ( appPath string ) string {
2019-04-29 13:08:21 -05:00
workPath := AppWorkPath
2017-11-03 03:56:20 -05:00
2019-04-29 13:08:21 -05:00
if giteaWorkPath , ok := os . LookupEnv ( "GITEA_WORK_DIR" ) ; ok {
2017-11-03 03:56:20 -05:00
workPath = giteaWorkPath
2019-04-29 13:08:21 -05:00
}
if len ( workPath ) == 0 {
2017-11-03 03:56:20 -05:00
i := strings . LastIndex ( appPath , "/" )
if i == - 1 {
workPath = appPath
} else {
workPath = appPath [ : i ]
}
}
2022-06-06 09:43:17 -05:00
workPath = strings . ReplaceAll ( workPath , "\\" , "/" )
if ! filepath . IsAbs ( workPath ) {
log . Info ( "Provided work path %s is not absolute - will be made absolute against the current working directory" , workPath )
absPath , err := filepath . Abs ( workPath )
if err != nil {
log . Error ( "Unable to absolute %s against the current working directory %v. Will absolute against the AppPath %s" , workPath , err , appPath )
workPath = filepath . Join ( appPath , workPath )
} else {
workPath = absPath
}
}
2020-10-11 15:27:20 -05:00
return strings . ReplaceAll ( workPath , "\\" , "/" )
2015-11-08 16:59:56 -05:00
}
func init ( ) {
2019-04-28 14:48:46 -05:00
IsWindows = runtime . GOOS == "windows"
2023-04-19 08:40:42 -05:00
if AppVer == "" {
AppVer = "dev"
}
2019-04-02 02:48:31 -05:00
// We can rely on log.CanColorStdout being set properly because modules/log/console_windows.go comes before modules/setting/setting.go lexicographically
2023-04-19 08:40:42 -05:00
// By default set this logger at Info - we'll change it later, but we need to start with something.
2021-06-26 19:56:58 -05:00
log . NewLogger ( 0 , "console" , "console" , fmt . Sprintf ( ` { "level": "info", "colorize": %t, "stacktraceLevel": "none"} ` , log . CanColorStdout ) )
2015-11-08 16:59:56 -05:00
var err error
2017-11-03 03:56:20 -05:00
if AppPath , err = getAppPath ( ) ; err != nil {
2019-04-02 02:48:31 -05:00
log . Fatal ( "Failed to get app path: %v" , err )
2014-05-25 19:11:25 -05:00
}
2017-11-03 03:56:20 -05:00
AppWorkPath = getWorkPath ( AppPath )
2014-05-25 19:11:25 -05:00
}
2015-03-18 03:25:55 -05:00
func forcePathSeparator ( path string ) {
if strings . Contains ( path , "\\" ) {
2019-04-02 02:48:31 -05:00
log . Fatal ( "Do not use '\\' or '\\\\' in paths, instead, please use '/' in all places" )
2015-03-18 03:25:55 -05:00
}
}
2016-08-09 19:41:18 -05:00
// IsRunUserMatchCurrentUser returns false if configured run user does not match
// actual user that runs the app. The first return value is the actual user name.
// This check is ignored under Windows since SSH remote login is not the main
// method to login on Windows.
func IsRunUserMatchCurrentUser ( runUser string ) ( string , bool ) {
2019-06-15 21:49:07 -05:00
if IsWindows || SSH . StartBuiltinServer {
2016-08-09 19:41:18 -05:00
return "" , true
}
currentUser := user . CurrentUsername ( )
return currentUser , runUser == currentUser
}
2019-04-29 13:08:21 -05:00
// SetCustomPathAndConf will set CustomPath and CustomConf with reference to the
// GITEA_CUSTOM environment variable and with provided overrides before stepping
// back to the default
2019-05-14 10:20:35 -05:00
func SetCustomPathAndConf ( providedCustom , providedConf , providedWorkPath string ) {
if len ( providedWorkPath ) != 0 {
AppWorkPath = filepath . ToSlash ( providedWorkPath )
}
2019-04-29 13:08:21 -05:00
if giteaCustom , ok := os . LookupEnv ( "GITEA_CUSTOM" ) ; ok {
CustomPath = giteaCustom
}
if len ( providedCustom ) != 0 {
CustomPath = providedCustom
}
2014-05-25 19:11:25 -05:00
if len ( CustomPath ) == 0 {
2017-11-03 03:56:20 -05:00
CustomPath = path . Join ( AppWorkPath , "custom" )
} else if ! filepath . IsAbs ( CustomPath ) {
CustomPath = path . Join ( AppWorkPath , CustomPath )
2014-05-25 19:11:25 -05:00
}
2019-04-29 13:08:21 -05:00
if len ( providedConf ) != 0 {
CustomConf = providedConf
2017-01-09 06:54:57 -05:00
}
2015-02-05 05:12:37 -05:00
if len ( CustomConf ) == 0 {
2017-11-03 03:56:20 -05:00
CustomConf = path . Join ( CustomPath , "conf/app.ini" )
2017-06-30 22:10:04 -05:00
} else if ! filepath . IsAbs ( CustomConf ) {
2017-11-03 03:56:20 -05:00
CustomConf = path . Join ( CustomPath , CustomConf )
2020-02-02 11:20:20 -05:00
log . Warn ( "Using 'custom' directory as relative origin for configuration file: '%s'" , CustomConf )
2015-02-05 05:12:37 -05:00
}
2019-04-29 13:08:21 -05:00
}
2023-02-19 11:12:01 -05:00
// PrepareAppDataPath creates app data directory if necessary
func PrepareAppDataPath ( ) error {
// FIXME: There are too many calls to MkdirAll in old code. It is incorrect.
// For example, if someDir=/mnt/vol1/gitea-home/data, if the mount point /mnt/vol1 is not mounted when Gitea runs,
// then gitea will make new empty directories in /mnt/vol1, all are stored in the root filesystem.
// The correct behavior should be: creating parent directories is end users' duty. We only create sub-directories in existing parent directories.
// For quickstart, the parent directories should be created automatically for first startup (eg: a flag or a check of INSTALL_LOCK).
// Now we can take the first step to do correctly (using Mkdir) in other packages, and prepare the AppDataPath here, then make a refactor in future.
st , err := os . Stat ( AppDataPath )
if os . IsNotExist ( err ) {
err = os . MkdirAll ( AppDataPath , os . ModePerm )
if err != nil {
return fmt . Errorf ( "unable to create the APP_DATA_PATH directory: %q, Error: %w" , AppDataPath , err )
}
return nil
}
2021-12-01 02:50:01 -05:00
2023-02-19 11:12:01 -05:00
if err != nil {
return fmt . Errorf ( "unable to use APP_DATA_PATH %q. Error: %w" , AppDataPath , err )
}
2021-12-01 02:50:01 -05:00
2023-02-19 11:12:01 -05:00
if ! st . IsDir ( ) /* also works for symlink */ {
return fmt . Errorf ( "the APP_DATA_PATH %q is not a directory (or symlink to a directory) and can't be used" , AppDataPath )
2021-12-01 02:50:01 -05:00
}
2023-02-19 11:12:01 -05:00
return nil
2021-12-01 02:50:01 -05:00
}
2023-02-19 11:12:01 -05:00
// InitProviderFromExistingFile initializes config provider from an existing config file (app.ini)
func InitProviderFromExistingFile ( ) {
2023-04-25 10:06:39 -05:00
var err error
CfgProvider , err = newConfigProviderFromFile ( CustomConf , false , "" )
if err != nil {
log . Fatal ( "InitProviderFromExistingFile: %v" , err )
}
2022-01-20 12:00:38 -05:00
}
2023-02-19 11:12:01 -05:00
// InitProviderAllowEmpty initializes config provider from file, it's also fine that if the config file (app.ini) doesn't exist
func InitProviderAllowEmpty ( ) {
2023-04-25 10:06:39 -05:00
var err error
CfgProvider , err = newConfigProviderFromFile ( CustomConf , true , "" )
if err != nil {
log . Fatal ( "InitProviderAllowEmpty: %v" , err )
}
2023-02-19 11:12:01 -05:00
}
// InitProviderAndLoadCommonSettingsForTest initializes config provider and load common setttings for tests
func InitProviderAndLoadCommonSettingsForTest ( extraConfigs ... string ) {
2023-04-25 10:06:39 -05:00
var err error
CfgProvider , err = newConfigProviderFromFile ( CustomConf , true , strings . Join ( extraConfigs , "\n" ) )
if err != nil {
log . Fatal ( "InitProviderAndLoadCommonSettingsForTest: %v" , err )
}
2023-02-19 11:12:01 -05:00
loadCommonSettingsFrom ( CfgProvider )
if err := PrepareAppDataPath ( ) ; err != nil {
log . Fatal ( "Can not prepare APP_DATA_PATH: %v" , err )
2022-10-16 18:29:26 -05:00
}
2023-02-20 00:20:30 -05:00
// register the dummy hash algorithm function used in the test fixtures
_ = hash . Register ( "dummy" , hash . NewDummyHasher )
PasswordHashAlgo , _ = hash . SetDefaultPasswordHashAlgorithm ( "dummy" )
2022-10-16 18:29:26 -05:00
}
2023-02-19 11:12:01 -05:00
// LoadCommonSettings loads common configurations from a configuration provider.
func LoadCommonSettings ( ) {
loadCommonSettingsFrom ( CfgProvider )
}
2019-08-15 09:46:21 -05:00
2023-02-19 11:12:01 -05:00
// loadCommonSettingsFrom loads common configurations from a configuration provider.
func loadCommonSettingsFrom ( cfg ConfigProvider ) {
// WARNNING: don't change the sequence except you know what you are doing.
loadRunModeFrom ( cfg )
loadLogFrom ( cfg )
loadServerFrom ( cfg )
loadSSHFrom ( cfg )
loadOAuth2From ( cfg )
loadSecurityFrom ( cfg )
loadAttachmentFrom ( cfg )
loadLFSFrom ( cfg )
loadTimeFrom ( cfg )
loadRepositoryFrom ( cfg )
loadPictureFrom ( cfg )
loadPackagesFrom ( cfg )
loadActionsFrom ( cfg )
loadUIFrom ( cfg )
loadAdminFrom ( cfg )
loadAPIFrom ( cfg )
loadMetricsFrom ( cfg )
loadCamoFrom ( cfg )
loadI18nFrom ( cfg )
loadGitFrom ( cfg )
loadMirrorFrom ( cfg )
loadMarkupFrom ( cfg )
loadOtherFrom ( cfg )
}
2014-07-24 15:31:59 -05:00
2023-02-19 11:12:01 -05:00
func loadRunModeFrom ( rootCfg ConfigProvider ) {
rootSec := rootCfg . Section ( "" )
RunUser = rootSec . Key ( "RUN_USER" ) . MustString ( user . CurrentUsername ( ) )
2021-10-07 03:52:08 -05:00
// The following is a purposefully undocumented option. Please do not run Gitea as root. It will only cause future headaches.
// Please don't use root as a bandaid to "fix" something that is broken, instead the broken thing should instead be fixed properly.
2023-02-19 11:12:01 -05:00
unsafeAllowRunAsRoot := rootSec . Key ( "I_AM_BEING_UNSAFE_RUNNING_AS_ROOT" ) . MustBool ( false )
2022-12-27 01:00:34 -05:00
RunMode = os . Getenv ( "GITEA_RUN_MODE" )
if RunMode == "" {
2023-02-19 11:12:01 -05:00
RunMode = rootSec . Key ( "RUN_MODE" ) . MustString ( "prod" )
2022-12-27 01:00:34 -05:00
}
2021-10-20 09:37:19 -05:00
IsProd = strings . EqualFold ( RunMode , "prod" )
2014-05-25 19:11:25 -05:00
// Does not check run user when the install lock is off.
2023-02-19 11:12:01 -05:00
installLock := rootCfg . Section ( "security" ) . Key ( "INSTALL_LOCK" ) . MustBool ( false )
if installLock {
2016-08-09 19:41:18 -05:00
currentUser , match := IsRunUserMatchCurrentUser ( RunUser )
if ! match {
2019-04-02 02:48:31 -05:00
log . Fatal ( "Expect user '%s' but current user is: %s" , RunUser , currentUser )
2016-08-09 19:41:18 -05:00
}
2014-05-25 19:11:25 -05:00
}
2021-10-07 03:52:08 -05:00
// check if we run as root
if os . Getuid ( ) == 0 {
if ! unsafeAllowRunAsRoot {
// Special thanks to VLC which inspired the wording of this messaging.
log . Fatal ( "Gitea is not supposed to be run as root. Sorry. If you need to use privileged TCP ports please instead use setcap and the `cap_net_bind_service` permission" )
}
log . Critical ( "You are running Gitea using the root user, and have purposely chosen to skip built-in protections around this. You have been warned against this." )
}
2020-12-22 06:13:50 -05:00
}
2023-02-19 11:12:01 -05:00
// LoadSettings initializes the settings for normal start up
func LoadSettings ( ) {
2023-03-16 02:22:54 -05:00
loadDBSetting ( CfgProvider )
2023-02-19 11:12:01 -05:00
loadServiceFrom ( CfgProvider )
loadOAuth2ClientFrom ( CfgProvider )
InitLogs ( false )
loadCacheFrom ( CfgProvider )
loadSessionFrom ( CfgProvider )
loadCorsFrom ( CfgProvider )
loadMailsFrom ( CfgProvider )
loadProxyFrom ( CfgProvider )
loadWebhookFrom ( CfgProvider )
loadMigrationsFrom ( CfgProvider )
loadIndexerFrom ( CfgProvider )
loadTaskFrom ( CfgProvider )
LoadQueueSettings ( )
loadProjectFrom ( CfgProvider )
loadMimeTypeMapFrom ( CfgProvider )
loadFederationFrom ( CfgProvider )
2014-04-10 13:20:58 -05:00
}
2021-06-16 18:32:57 -05:00
2023-02-19 11:12:01 -05:00
// LoadSettingsForInstall initializes the settings for install
func LoadSettingsForInstall ( ) {
2023-03-16 02:22:54 -05:00
loadDBSetting ( CfgProvider )
2023-02-19 11:12:01 -05:00
loadServiceFrom ( CfgProvider )
loadMailerFrom ( CfgProvider )
2021-06-16 18:32:57 -05:00
}