Fix all possible setting error related storages and added some tests

custom/conf/app.example.ini

@@ -2484,6 +2484,10 @@ ROUTER = console
 ;; Enable/Disable package registry capabilities
 ;ENABLED = true
 ;;
+;STORAGE_TYPE = local
+;; override the minio base path if storage type is minio
+;MINIO_BASE_PATH = packages/
+;;
 ;; Path for chunked uploads. Defaults to APP_DATA_PATH + `tmp/package-upload`
 ;CHUNKED_UPLOAD_PATH = tmp/package-upload
 ;;
@@ -2534,6 +2538,19 @@ ROUTER = console
 ;; storage type
 ;STORAGE_TYPE = local
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; repo-archive storage will override storage
+;;
+;[repo-archive]
+;STORAGE_TYPE = local
+;;
+;; Where your lfs files reside, default is data/lfs.
+;PATH = data/repo-archive
+;;
+;; override the minio base path if storage type is minio
+;MINIO_BASE_PATH = repo-archive/
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; settings for repository archives, will override storage setting
@@ -2553,6 +2570,9 @@ ROUTER = console
 ;;
 ;; Where your lfs files reside, default is data/lfs.
 ;PATH = data/lfs
+;;
+;; override the minio base path if storage type is minio
+;MINIO_BASE_PATH = lfs/
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2602,6 +2622,9 @@ ROUTER = console
 ; [actions]
 ;; Enable/Disable actions capabilities
 ;ENABLED = false
+;;
+;STORAGE_TYPE = local
+;;
 ;; Default address to get action plugins, e.g. the default value means downloading from "https://gitea.com/actions/checkout" for "uses: actions/checkout@v3"
 ;DEFAULT_ACTIONS_URL = https://gitea.com
 

docs/content/doc/administration/config-cheat-sheet.en-us.md

@@ -1340,6 +1340,11 @@ is `data/repo-archive` and the default of `MINIO_BASE_PATH` is `repo-archive/`.
 - `MINIO_USE_SSL`: **false**: Minio enabled ssl only available when `STORAGE_TYPE` is `minio`
 - `MINIO_INSECURE_SKIP_VERIFY`: **false**: Minio skip SSL verification available when STORAGE_TYPE is `minio`
 
+## Repository Archives (`repo-archive`)
+
+- `STORAGE_TYPE`: **local**: Storage type for actions logs, `local` for local disk or `minio` for s3 compatible object storage service, default is `local` or other name defined with `[storage.xxx]`
+- `MINIO_BASE_PATH`: **actions_log/**: Minio base path on the bucket only available when STORAGE_TYPE is `minio`
+
 ## Proxy (`proxy`)
 
 - `PROXY_ENABLED`: **false**: Enable the proxy if true, all requests to external via HTTP will be affected, if false, no proxy will be used even environment http_proxy/https_proxy
@@ -1358,6 +1363,8 @@ PROXY_HOSTS = *.github.com
 
 - `ENABLED`: **false**: Enable/Disable actions capabilities
 - `DEFAULT_ACTIONS_URL`: **https://gitea.com**: Default address to get action plugins, e.g. the default value means downloading from "<https://gitea.com/actions/checkout>" for "uses: actions/checkout@v3"
+- `STORAGE_TYPE`: **local**: Storage type for actions logs, `local` for local disk or `minio` for s3 compatible object storage service, default is `local` or other name defined with `[storage.xxx]`
+- `MINIO_BASE_PATH`: **actions_log/**: Minio base path on the bucket only available when STORAGE_TYPE is `minio`
 
 `DEFAULT_ACTIONS_URL` indicates where should we find the relative path action plugin. i.e. when use an action in a workflow file like
 

modules/setting/actions.go

@@ -3,9 +3,7 @@
 
 package setting
 
-import (
- "code.gitea.io/gitea/modules/log"
-)
+import "fmt"
 
 // Actions settings
 var (
@@ -19,11 +17,14 @@ var (
  }
 )
 
-func loadActionsFrom(rootCfg ConfigProvider) {
+func loadActionsFrom(rootCfg ConfigProvider) error {
  sec := rootCfg.Section("actions")
  if err := sec.MapTo(&Actions); err != nil {
- log.Fatal("Failed to map Actions settings: %v", err)
+ return fmt.Errorf("failed to map Actions settings: %v", err)
  }
+ sec.Key("MINIO_BASE_PATH").MustString("actions_log/")
+ storageType := sec.Key("STORAGE_TYPE").MustString("")
 
- Actions.Storage = getStorage(rootCfg, "actions_log", "", nil)
+ Actions.Storage = getStorage(rootCfg, "actions_log", storageType, sec)
+ return nil
 }

modules/setting/actions_test.go

@@ -0,0 +1,64 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package setting
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ ini "gopkg.in/ini.v1"
+)
+
+func Test_getStorageInheritNameSectionTypeForActions(t *testing.T) {
+ iniStr := `
+ [storage]
+ STORAGE_TYPE = minio
+ `
+ cfg, err := ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+ assert.NoError(t, loadActionsFrom(cfg))
+
+ assert.EqualValues(t, "minio", Actions.Storage.Type)
+ assert.EqualValues(t, "actions_log/", cfg.Section("actions").Key("MINIO_BASE_PATH").MustString(""))
+
+ iniStr = `
+[storage.actions_log]
+STORAGE_TYPE = minio
+`
+ cfg, err = ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+ assert.NoError(t, loadActionsFrom(cfg))
+
+ assert.EqualValues(t, "minio", Actions.Storage.Type)
+ assert.EqualValues(t, "actions_log/", cfg.Section("actions").Key("MINIO_BASE_PATH").MustString(""))
+
+ iniStr = `
+[actions]
+STORAGE_TYPE = my_minio
+
+[storage.my_minio]
+STORAGE_TYPE = minio
+`
+ cfg, err = ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+ assert.NoError(t, loadActionsFrom(cfg))
+
+ assert.EqualValues(t, "minio", Actions.Storage.Type)
+ assert.EqualValues(t, "actions_log/", cfg.Section("actions").Key("MINIO_BASE_PATH").MustString(""))
+
+ iniStr = `
+[actions]
+STORAGE_TYPE = my_minio
+MINIO_BASE_PATH = my_actions_log/
+
+[storage.my_minio]
+STORAGE_TYPE = minio
+`
+ cfg, err = ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+ assert.NoError(t, loadActionsFrom(cfg))
+
+ assert.EqualValues(t, "minio", Actions.Storage.Type)
+ assert.EqualValues(t, "my_actions_log/", cfg.Section("actions").Key("MINIO_BASE_PATH").MustString(""))
+}

modules/setting/attachment.go

@@ -20,7 +20,7 @@ var Attachment = struct {
  Enabled: true,
 }
 
-func loadAttachmentFrom(rootCfg ConfigProvider) {
+func loadAttachmentFrom(rootCfg ConfigProvider) error {
  sec := rootCfg.Section("attachment")
  storageType := sec.Key("STORAGE_TYPE").MustString("")
 
@@ -30,4 +30,6 @@ func loadAttachmentFrom(rootCfg ConfigProvider) {
  Attachment.MaxSize = sec.Key("MAX_SIZE").MustInt64(4)
  Attachment.MaxFiles = sec.Key("MAX_FILES").MustInt(5)
  Attachment.Enabled = sec.Key("ENABLED").MustBool(true)
+
+ return nil
 }

modules/setting/attachment_test.go

@@ -0,0 +1,114 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package setting
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ ini "gopkg.in/ini.v1"
+)
+
+func Test_getStorageCustomType(t *testing.T) {
+ iniStr := `
+[attachment]
+STORAGE_TYPE = my_minio
+MINIO_BUCKET = gitea-attachment
+
+[storage.my_minio]
+STORAGE_TYPE = minio
+MINIO_ENDPOINT = my_minio:9000
+`
+ cfg, err := ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+
+ assert.NoError(t, loadAttachmentFrom(cfg))
+
+ assert.EqualValues(t, "minio", Attachment.Storage.Type)
+ assert.EqualValues(t, "my_minio:9000", Attachment.Storage.Section.Key("MINIO_ENDPOINT").String())
+ assert.EqualValues(t, "gitea-attachment", Attachment.Storage.Section.Key("MINIO_BUCKET").String())
+}
+
+func Test_getStorageNameSectionOverridesTypeSection(t *testing.T) {
+ iniStr := `
+[attachment]
+STORAGE_TYPE = minio
+
+[storage.attachments]
+MINIO_BUCKET = gitea-attachment
+
+[storage.minio]
+MINIO_BUCKET = gitea
+`
+ cfg, err := ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+
+ assert.NoError(t, loadAttachmentFrom(cfg))
+
+ assert.EqualValues(t, "minio", Attachment.Storage.Type)
+ assert.EqualValues(t, "gitea-attachment", Attachment.Storage.Section.Key("MINIO_BUCKET").String())
+}
+
+func Test_getStorageTypeSectionOverridesStorageSection(t *testing.T) {
+ iniStr := `
+[attachment]
+STORAGE_TYPE = minio
+
+[storage.minio]
+MINIO_BUCKET = gitea-minio
+
+[storage]
+MINIO_BUCKET = gitea
+`
+ cfg, err := ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+
+ assert.NoError(t, loadAttachmentFrom(cfg))
+
+ assert.EqualValues(t, "minio", Attachment.Storage.Type)
+ assert.EqualValues(t, "gitea-minio", Attachment.Storage.Section.Key("MINIO_BUCKET").String())
+}
+
+func Test_getStorageSpecificOverridesStorage(t *testing.T) {
+ iniStr := `
+[attachment]
+STORAGE_TYPE = minio
+MINIO_BUCKET = gitea-attachment
+
+[storage.attachments]
+MINIO_BUCKET = gitea
+
+[storage]
+STORAGE_TYPE = local
+`
+ cfg, err := ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+
+ assert.NoError(t, loadAttachmentFrom(cfg))
+
+ assert.EqualValues(t, "minio", Attachment.Storage.Type)
+ assert.EqualValues(t, "gitea-attachment", Attachment.Storage.Section.Key("MINIO_BUCKET").String())
+}
+
+func Test_getStorageGetDefaults(t *testing.T) {
+ cfg, err := ini.Load([]byte(""))
+ assert.NoError(t, err)
+
+ assert.NoError(t, loadAttachmentFrom(cfg))
+
+ assert.EqualValues(t, "gitea", Attachment.Storage.Section.Key("MINIO_BUCKET").String())
+}
+
+func Test_getStorageInheritNameSectionType(t *testing.T) {
+ iniStr := `
+[storage.attachments]
+STORAGE_TYPE = minio
+`
+ cfg, err := ini.Load([]byte(iniStr))
+ assert.NoError(t, err)
+
+ assert.NoError(t, loadAttachmentFrom(cfg))
+
+ assert.EqualValues(t, "minio", Attachment.Storage.Type)
+}

modules/setting/lfs.go

@@ -5,10 +5,10 @@ package setting
 
 import (
  "encoding/base64"
+ "fmt"
  "time"
 
  "code.gitea.io/gitea/modules/generate"
- "code.gitea.io/gitea/modules/log"
 
  ini "gopkg.in/ini.v1"
 )
@@ -25,10 +25,10 @@ var LFS = struct {
  Storage
 }{}
 
-func loadLFSFrom(rootCfg ConfigProvider) {
+func loadLFSFrom(rootCfg ConfigProvider) error {
  sec := rootCfg.Section("server")
  if err := sec.MapTo(&LFS); err != nil {
- log.Fatal("Failed to map LFS settings: %v", err)
+ return fmt.Errorf("failed to map LFS settings: %v", err)
  }
 
  lfsSec := rootCfg.Section("lfs")
@@ -50,21 +50,23 @@ func loadLFSFrom(rootCfg ConfigProvider) {
 
  LFS.HTTPAuthExpiry = sec.Key("LFS_HTTP_AUTH_EXPIRY").MustDuration(20 * time.Minute)
 
- if LFS.StartServer {
- LFS.JWTSecretBytes = make([]byte, 32)
- n, err := base64.RawURLEncoding.Decode(LFS.JWTSecretBytes, []byte(LFS.JWTSecretBase64))
-
- if err != nil || n != 32 {
- LFS.JWTSecretBase64, err = generate.NewJwtSecretBase64()
- if err != nil {
- log.Fatal("Error generating JWT Secret for custom config: %v", err)
- return
- }
-
- // Save secret
- CreateOrAppendToCustomConf("server.LFS_JWT_SECRET", func(cfg *ini.File) {
- cfg.Section("server").Key("LFS_JWT_SECRET").SetValue(LFS.JWTSecretBase64)
- })
+ if !LFS.StartServer {
+ return nil
+ }
+
+ LFS.JWTSecretBytes = make([]byte, 32)
+ n, err := base64.RawURLEncoding.Decode(LFS.JWTSecretBytes, []byte(LFS.JWTSecretBase64))
+
+ if err != nil || n != 32 {
+ LFS.JWTSecretBase64, err = generate.NewJwtSecretBase64()
+ if err != nil {
+ return fmt.Errorf("error generating JWT Secret for custom config: %v", err)
  }
+
+ // Save secret
+ CreateOrAppendToCustomConf("server.LFS_JWT_SECRET", func(cfg *ini.File) {
+ cfg.Section("server").Key("LFS_JWT_SECRET").SetValue(LFS.JWTSecretBase64)
+ })
  }
+ return nil
 }