Remove sub temporary path configurations with a fixed sub path

Author: lunny

cmd/dump.go

@@ -48,7 +48,7 @@ var CmdDump = &cli.Command{
 		&cli.StringFlag{
 			Name:    "tempdir",
 			Aliases: []string{"t"},
-			Value:   setting.TempPath,
+			Value:   filepath.Join(setting.TempPath, "dump"),
 			Usage:   "Temporary dir path",
 		},
 		&cli.StringFlag{
@@ -194,8 +194,8 @@ func runDump(ctx *cli.Context) error {
 		log.Info("Skipping database")
 	} else {
 		tmpDir := ctx.String("tempdir")
-		if _, err := os.Stat(tmpDir); os.IsNotExist(err) {
-			fatal("Path does not exist: %s", tmpDir)
+		if err := os.MkdirAll(tmpDir, os.ModePerm); err != nil {
+			fatal("Unable to create temporary directory: %s (%v)", tmpDir, err)
 		}
 
 		dbDump, err := os.CreateTemp(tmpDir, "gitea-db.sql")

custom/conf/app.example.ini

@@ -201,10 +201,6 @@ RUN_USER = ; git
 ;; relative paths are made absolute relative to the APP_DATA_PATH
 ;SSH_SERVER_HOST_KEYS=ssh/gitea.rsa, ssh/gogs.rsa
 ;;
-;; Directory to create temporary files in when testing public keys using ssh-keygen,
-;; default is the system temporary directory.
-;SSH_KEY_TEST_PATH =
-;;
 ;; Use `ssh-keygen` to parse public SSH keys. The value is passed to the shell. By default, Gitea does the parsing itself.
 ;SSH_KEYGEN_PATH =
 ;;
@@ -1073,15 +1069,6 @@ LEVEL = Info
 ;; Separate extensions with a comma. To line wrap files without an extension, just put a comma
 ;LINE_WRAP_EXTENSIONS = .txt,.md,.markdown,.mdown,.mkd,.livemd,
 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;[repository.local]
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;; Path for local repository copy. Defaults to  TEMP_PATH + `local-repo`
-;LOCAL_COPY_PATH = local-repo
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;[repository.upload]
@@ -1091,9 +1078,6 @@ LEVEL = Info
 ;; Whether repository file uploads are enabled. Defaults to `true`
 ;ENABLED = true
 ;;
-;; Path for uploads. Defaults to TEMP_PATH + `uploads`
-;TEMP_PATH = uploads
-;;
 ;; Comma-separated list of allowed file extensions (`.zip`), mime types (`text/plain`) or wildcard type (`image/*`, `audio/*`, `video/*`). Empty value or `*/*` allows all types.
 ;ALLOWED_TYPES =
 ;;
@@ -2592,9 +2576,6 @@ LEVEL = Info
 ;; Currently, only `minio` and `azureblob` is supported.
 ;SERVE_DIRECT = false
 ;;
-;; Path for chunked uploads. Defaults it's `package-upload` under `TEMP_PATH` unless it's an absolute path.
-;CHUNKED_UPLOAD_PATH = package-upload
-;;
 ;; Maximum count of package versions a single owner can have (`-1` means no limits)
 ;LIMIT_TOTAL_OWNER_COUNT = -1
 ;; Maximum size of packages a single owner can use (`-1` means no limits, format `1000`, `1 MB`, `1 GiB`)

models/asymkey/ssh_key_parse.go

@@ -262,7 +262,7 @@ func SSHNativeParsePublicKey(keyLine string) (string, int, error) {
 // writeTmpKeyFile writes key content to a temporary file
 // and returns the name of that file, along with any possible errors.
 func writeTmpKeyFile(content string) (string, error) {
-	tmpFile, err := os.CreateTemp(setting.SSH.KeyTestPath, "gitea_keytest")
+	tmpFile, err := os.CreateTemp(setting.GetSSHKeyTestPath(), "gitea_keytest")
 	if err != nil {
 		return "", fmt.Errorf("TempFile: %w", err)
 	}

models/repo/upload.go

@@ -53,7 +53,7 @@ func init() {
 
 // UploadLocalPath returns where uploads is stored in local file system based on given UUID.
 func UploadLocalPath(uuid string) string {
-	return filepath.Join(setting.Repository.Upload.TempPath, uuid[0:1], uuid[1:2], uuid)
+	return filepath.Join(setting.GetRepositoryUploadTempPath(), uuid[0:1], uuid[1:2], uuid)
 }
 
 // LocalPath returns where uploads are temporarily stored in local file system.

modules/repository/temp.go

@@ -16,12 +16,7 @@ import (
 
 // localCopyPath returns the local repository temporary copy path.
 func localCopyPath() string {
-	if setting.Repository.Local.LocalCopyPath == "" {
-		return filepath.Join(setting.TempPath, "local-repo")
-	} else if !filepath.IsAbs(setting.Repository.Local.LocalCopyPath) {
-		return filepath.Join(setting.TempPath, setting.Repository.Local.LocalCopyPath)
-	}
-	return setting.Repository.Local.LocalCopyPath
+	return filepath.Join(setting.TempPath, "local-repo")
 }
 
 // CreateTemporaryPath creates a temporary path

modules/setting/packages.go

@@ -15,9 +15,8 @@ import (
 // Package registry settings
 var (
 	Packages = struct {
-		Storage           *Storage
-		Enabled           bool
-		ChunkedUploadPath string
+		Storage *Storage
+		Enabled bool
 
 		LimitTotalOwnerCount int64
 		LimitTotalOwnerSize  int64
@@ -51,6 +50,10 @@ var (
 	}
 )
 
+func GetPacakgeUploadTempPath() string {
+	return filepath.Join(TempPath, "package-upload")
+}
+
 func loadPackagesFrom(rootCfg ConfigProvider) (err error) {
 	sec, _ := rootCfg.GetSection("packages")
 	if sec == nil {
@@ -67,14 +70,9 @@ func loadPackagesFrom(rootCfg ConfigProvider) (err error) {
 		return err
 	}
 
-	Packages.ChunkedUploadPath = filepath.ToSlash(sec.Key("CHUNKED_UPLOAD_PATH").MustString("package-upload"))
-	if !filepath.IsAbs(Packages.ChunkedUploadPath) {
-		Packages.ChunkedUploadPath = filepath.Join(TempPath, Packages.ChunkedUploadPath)
-	}
-
 	if HasInstallLock(rootCfg) {
-		if err := os.MkdirAll(Packages.ChunkedUploadPath, os.ModePerm); err != nil {
-			return fmt.Errorf("unable to create chunked upload directory: %s (%v)", Packages.ChunkedUploadPath, err)
+		if err := os.MkdirAll(GetPacakgeUploadTempPath(), os.ModePerm); err != nil {
+			return fmt.Errorf("unable to create chunked upload directory: %s (%v)", GetPacakgeUploadTempPath(), err)
 		}
 	}
 

modules/setting/repository.go

@@ -62,17 +62,11 @@ var (
 		// Repository upload settings
 		Upload struct {
 			Enabled      bool
-			TempPath     string
 			AllowedTypes string
 			FileMaxSize  int64
 			MaxFiles     int
 		} `ini:"-"`
 
-		// Repository local settings
-		Local struct {
-			LocalCopyPath string
-		} `ini:"-"`
-
 		// Pull request settings
 		PullRequest struct {
 			WorkInProgressPrefixes                   []string
@@ -181,25 +175,16 @@ var (
 		// Repository upload settings
 		Upload: struct {
 			Enabled      bool
-			TempPath     string
 			AllowedTypes string
 			FileMaxSize  int64
 			MaxFiles     int
 		}{
 			Enabled:      true,
-			TempPath:     "uploads",
 			AllowedTypes: "",
 			FileMaxSize:  50,
 			MaxFiles:     5,
 		},
 
-		// Repository local settings
-		Local: struct {
-			LocalCopyPath string
-		}{
-			LocalCopyPath: "local-repo",
-		},
-
 		// Pull request settings
 		PullRequest: struct {
 			WorkInProgressPrefixes                   []string
@@ -308,8 +293,6 @@ func loadRepositoryFrom(rootCfg ConfigProvider) {
 		log.Fatal("Failed to map Repository.Editor settings: %v", err)
 	} else if err = rootCfg.Section("repository.upload").MapTo(&Repository.Upload); err != nil {
 		log.Fatal("Failed to map Repository.Upload settings: %v", err)
-	} else if err = rootCfg.Section("repository.local").MapTo(&Repository.Local); err != nil {
-		log.Fatal("Failed to map Repository.Local settings: %v", err)
 	} else if err = rootCfg.Section("repository.pull-request").MapTo(&Repository.PullRequest); err != nil {
 		log.Fatal("Failed to map Repository.PullRequest settings: %v", err)
 	}
@@ -361,13 +344,11 @@ func loadRepositoryFrom(rootCfg ConfigProvider) {
 		}
 	}
 
-	if Repository.Upload.TempPath == "" {
-		Repository.Upload.TempPath = filepath.Join(TempPath, "uploads")
-	} else if !filepath.IsAbs(Repository.Upload.TempPath) {
-		Repository.Upload.TempPath = filepath.Join(TempPath, Repository.Upload.TempPath)
-	}
-
 	if err := loadRepoArchiveFrom(rootCfg); err != nil {
 		log.Fatal("loadRepoArchiveFrom: %v", err)
 	}
 }
+
+func GetRepositoryUploadTempPath() string {
+	return filepath.Join(TempPath, "uploads")
+}

modules/setting/ssh.go

@@ -4,7 +4,6 @@
 package setting
 
 import (
-	"os"
 	"path/filepath"
 	"strings"
 	"text/template"
@@ -31,7 +30,6 @@ var SSH = struct {
 	ServerKeyExchanges                    []string           `ini:"SSH_SERVER_KEY_EXCHANGES"`
 	ServerMACs                            []string           `ini:"SSH_SERVER_MACS"`
 	ServerHostKeys                        []string           `ini:"SSH_SERVER_HOST_KEYS"`
-	KeyTestPath                           string             `ini:"SSH_KEY_TEST_PATH"`
 	KeygenPath                            string             `ini:"SSH_KEYGEN_PATH"`
 	AuthorizedKeysBackup                  bool               `ini:"SSH_AUTHORIZED_KEYS_BACKUP"`
 	AuthorizedPrincipalsBackup            bool               `ini:"SSH_AUTHORIZED_PRINCIPALS_BACKUP"`
@@ -61,7 +59,6 @@ var SSH = struct {
 	MinimumKeySizeCheck:           true,
 	MinimumKeySizes:               map[string]int{"ed25519": 256, "ed25519-sk": 256, "ecdsa": 256, "ecdsa-sk": 256, "rsa": 3071},
 	ServerHostKeys:                []string{"ssh/gitea.rsa", "ssh/gogs.rsa"},
-	KeyTestPath:                   "ssh_key_test",
 	AuthorizedKeysCommandTemplate: "{{.AppPath}} --config={{.CustomConf}} serv key-{{.Key.ID}}",
 	PerWriteTimeout:               PerWriteTimeout,
 	PerWritePerKbTimeout:          PerWritePerKbTimeout,
@@ -99,6 +96,10 @@ func parseAuthorizedPrincipalsAllow(values []string) ([]string, bool) {
 	return authorizedPrincipalsAllow, true
 }
 
+func GetSSHKeyTestPath() string {
+	return filepath.Join(TempPath, "ssh_key_test")
+}
+
 func loadSSHFrom(rootCfg ConfigProvider) {
 	sec := rootCfg.Section("server")
 	if len(SSH.Domain) == 0 {
@@ -133,14 +134,6 @@ func loadSSHFrom(rootCfg ConfigProvider) {
 		}
 	}
 
-	SSH.KeyTestPath = sec.Key("SSH_KEY_TEST_PATH").MustString("ssh_key_test")
-	if !filepath.IsAbs(SSH.KeyTestPath) {
-		SSH.KeyTestPath = filepath.Join(TempPath, SSH.KeyTestPath)
-	}
-	if err := os.MkdirAll(SSH.KeyTestPath, os.ModePerm); err != nil {
-		log.Fatal("failed to create directory %q for ssh key test: %w", SSH.KeyTestPath, err)
-	}
-
 	SSH.KeygenPath = sec.Key("SSH_KEYGEN_PATH").String()
 	SSH.Port = sec.Key("SSH_PORT").MustInt(22)
 	SSH.ListenPort = sec.Key("SSH_LISTEN_PORT").MustInt(SSH.Port)

modules/ssh/init.go

@@ -32,6 +32,11 @@ func Init() error {
 
 	builtinUnused()
 
+	// FIXME: why 0o644 for a directory .....
+	if err := os.MkdirAll(setting.GetSSHKeyTestPath(), 0o644); err != nil {
+		return fmt.Errorf("failed to create directory %q for ssh key test: %w", setting.GetSSHKeyTestPath(), err)
+	}
+
 	if len(setting.SSH.TrustedUserCAKeys) > 0 && setting.SSH.AuthorizedPrincipalsEnabled {
 		caKeysFileName := setting.SSH.TrustedUserCAKeysFile
 		caKeysFileDir := filepath.Dir(caKeysFileName)

services/packages/container/blob_uploader.go

@@ -31,7 +31,7 @@ type BlobUploader struct {
 }
 
 func buildFilePath(id string) string {
-	return util.FilePathJoinAbs(setting.Packages.ChunkedUploadPath, id)
+	return util.FilePathJoinAbs(setting.GetPacakgeUploadTempPath(), id)
 }
 
 // NewBlobUploader creates a new blob uploader for the given id