Add test to confirm storage could be inherit correctly

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,32 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package setting
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_AttachmentStorage(t *testing.T) {
+	iniStr := `
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[storage]
+STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadAttachmentFrom(cfg))
+	storage := Attachment.Storage
+
+	assert.EqualValues(t, "minio", storage.Type)
+	assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String())
+}

modules/setting/packages.go

@@ -4,6 +4,7 @@
 package setting
 
 import (
+	"fmt"
 	"math"
 	"net/url"
 	"os"
@@ -51,13 +52,13 @@ var (
 	}
 )
 
-func loadPackagesFrom(rootCfg ConfigProvider) {
+func loadPackagesFrom(rootCfg ConfigProvider) error {
 	sec := rootCfg.Section("packages")
 	if err := sec.MapTo(&Packages); err != nil {
-		log.Fatal("Failed to map Packages settings: %v", err)
+		return fmt.Errorf("failed to map Packages settings: %v", err)
 	}
 
-	Packages.Storage = getStorage(rootCfg, "packages", "", nil)
+	Packages.Storage = getStorage(rootCfg, "packages", sec.Key("STORAGE_TYPE").String(), nil)
 
 	appURL, _ := url.Parse(AppURL)
 	Packages.RegistryHost = appURL.Host
@@ -93,6 +94,8 @@ func loadPackagesFrom(rootCfg ConfigProvider) {
 	Packages.LimitSizeRubyGems = mustBytes(sec, "LIMIT_SIZE_RUBYGEMS")
 	Packages.LimitSizeSwift = mustBytes(sec, "LIMIT_SIZE_SWIFT")
 	Packages.LimitSizeVagrant = mustBytes(sec, "LIMIT_SIZE_VAGRANT")
+
+	return nil
 }
 
 func mustBytes(section ConfigSection, key string) int64 {

modules/setting/packages_test.go

@@ -29,3 +29,117 @@ func TestMustBytes(t *testing.T) {
 	assert.EqualValues(t, 1782579, test("1.7mib"))
 	assert.EqualValues(t, -1, test("1 yib")) // too large
 }
+
+func Test_PackageStorage1(t *testing.T) {
+	iniStr := `
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[packages]
+MINIO_BASE_PATH = packages/
+SERVE_DIRECT = true
+
+[storage]
+STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	storage := Packages.Storage
+
+	assert.EqualValues(t, "minio", storage.Type)
+	assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String())
+	assert.EqualValues(t, "packages/", storage.Section.Key("MINIO_BASE_PATH").String())
+	assert.True(t, storage.Section.Key("SERVE_DIRECT").MustBool(false))
+}
+
+func Test_PackageStorage2(t *testing.T) {
+	iniStr := `
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[storage.packages]
+MINIO_BASE_PATH = packages/
+SERVE_DIRECT = true
+
+[storage]
+STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	storage := Packages.Storage
+
+	assert.EqualValues(t, "minio", storage.Type)
+	assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String())
+	assert.EqualValues(t, "packages/", storage.Section.Key("MINIO_BASE_PATH").String())
+	assert.True(t, storage.Section.Key("SERVE_DIRECT").MustBool(false))
+}
+
+func Test_PackageStorage3(t *testing.T) {
+	iniStr := `
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[packages]
+STORAGE_TYPE            = my_cfg
+MINIO_BASE_PATH = my_packages/
+SERVE_DIRECT = true
+
+[storage.my_cfg]
+STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	storage := Packages.Storage
+
+	assert.EqualValues(t, "minio", storage.Type)
+	assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String())
+	assert.EqualValues(t, "my_packages/", storage.Section.Key("MINIO_BASE_PATH").String())
+	assert.True(t, storage.Section.Key("SERVE_DIRECT").MustBool(false))
+}
+
+func Test_PackageStorage4(t *testing.T) {
+	iniStr := `
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[storage.packages]
+STORAGE_TYPE            = my_cfg
+MINIO_BASE_PATH = my_packages/
+SERVE_DIRECT = true
+
+[storage.my_cfg]
+STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadPackagesFrom(cfg))
+	storage := Packages.Storage
+
+	assert.EqualValues(t, "minio", storage.Type)
+	assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String())
+	assert.EqualValues(t, "my_packages/", storage.Section.Key("MINIO_BASE_PATH").String())
+	assert.True(t, storage.ServeDirect)
+}

modules/setting/repository.go

@@ -359,5 +359,12 @@ func loadRepositoryFrom(rootCfg ConfigProvider) {
 		Repository.Upload.TempPath = path.Join(AppWorkPath, Repository.Upload.TempPath)
 	}
 
+	if err := loadRepoArchive(rootCfg); err != nil {
+		log.Fatal("Failed to load repository archive settings: %v", err)
+	}
+}
+
+func loadRepoArchive(rootCfg ConfigProvider) error {
 	RepoArchive.Storage = getStorage(rootCfg, "repo-archive", "", nil)
+	return nil
 }

modules/setting/repository_test.go

@@ -0,0 +1,55 @@
+// Copyright 2023 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package setting
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_RepoArchiveStorage(t *testing.T) {
+	iniStr := `
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[storage]
+STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	cfg, err := NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadRepoArchive(cfg))
+	storage := RepoArchive.Storage
+
+	assert.EqualValues(t, "minio", storage.Type)
+	assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String())
+
+	iniStr = `
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+[storage.repo-archive]
+STORAGE_TYPE = s3
+
+[storage.s3]
+STORAGE_TYPE            = minio
+MINIO_ENDPOINT          = s3.my-domain.net
+MINIO_BUCKET            = gitea
+MINIO_LOCATION          = homenet
+MINIO_USE_SSL           = true
+MINIO_ACCESS_KEY_ID     = correct_key
+MINIO_SECRET_ACCESS_KEY = correct_key
+`
+	cfg, err = NewConfigProviderFromData(iniStr)
+	assert.NoError(t, err)
+
+	assert.NoError(t, loadRepoArchive(cfg))
+	storage = RepoArchive.Storage
+
+	assert.EqualValues(t, "minio", storage.Type)
+	assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String())
+}

modules/setting/setting.go

@@ -11,6 +11,7 @@ import (
 	"os/exec"
 	"path"
 	"path/filepath"
+	"reflect"
 	"runtime"
 	"strings"
 	"time"
@@ -210,6 +211,15 @@ func Init(opts *Options) {
 	}
 }
 
+func mustLoad(cfg ConfigProvider, fn func(ConfigProvider) error) {
+	err := fn(cfg)
+	if err != nil {
+		ptr := reflect.ValueOf(fn).Pointer()
+		fi := runtime.FuncForPC(ptr)
+		log.Fatal("%s failed: %v", fi.Name(), err)
+	}
+}
+
 // loadCommonSettingsFrom loads common configurations from a configuration provider.
 func loadCommonSettingsFrom(cfg ConfigProvider) {
 	// WARNING: don't change the sequence except you know what you are doing.
@@ -222,12 +232,12 @@ func loadCommonSettingsFrom(cfg ConfigProvider) {
 
 	loadOAuth2From(cfg)
 	loadSecurityFrom(cfg)
-	loadAttachmentFrom(cfg)
+	mustLoad(cfg, loadAttachmentFrom)
 	loadLFSFrom(cfg)
 	loadTimeFrom(cfg)
 	loadRepositoryFrom(cfg)
 	loadPictureFrom(cfg)
-	loadPackagesFrom(cfg)
+	mustLoad(cfg, loadPackagesFrom)
 	loadActionsFrom(cfg)
 	loadUIFrom(cfg)
 	loadAdminFrom(cfg)

modules/setting/storage.go

@@ -28,10 +28,10 @@ func (s *Storage) MapTo(v interface{}) error {
 	return nil
 }
 
-func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSection) Storage {
-	const sectionName = "storage"
-	sec := rootCfg.Section(sectionName)
+const sectionName = "storage"
 
+func getDefaultStorageSec(rootCfg ConfigProvider) ConfigSection {
+	sec := rootCfg.Section(sectionName)
 	// Global Defaults
 	sec.Key("MINIO_ENDPOINT").MustString("localhost:9000")
 	sec.Key("MINIO_ACCESS_KEY_ID").MustString("")
@@ -41,7 +41,21 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio
 	sec.Key("MINIO_USE_SSL").MustBool(false)
 	sec.Key("MINIO_INSECURE_SKIP_VERIFY").MustBool(false)
 	sec.Key("MINIO_CHECKSUM_ALGORITHM").MustString("default")
+	return sec
+}
+
+func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSection) Storage {
+	defaultSec := getDefaultStorageSec(rootCfg)
+
+	overrides := make([]ConfigSection, 0, 3)
+	nameSec, err := rootCfg.GetSection(sectionName + "." + name)
+	if err == nil {
+		overrides = append(overrides, nameSec)
+	}
 
+	if targetSec == nil {
+		targetSec = nameSec
+	}
 	if targetSec == nil {
 		targetSec, _ = rootCfg.NewSection(name)
 	}
@@ -50,12 +64,6 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio
 	storage.Section = targetSec
 	storage.Type = typ
 
-	overrides := make([]ConfigSection, 0, 3)
-	nameSec, err := rootCfg.GetSection(sectionName + "." + name)
-	if err == nil {
-		overrides = append(overrides, nameSec)
-	}
-
 	typeSec, err := rootCfg.GetSection(sectionName + "." + typ)
 	if err == nil {
 		overrides = append(overrides, typeSec)
@@ -64,7 +72,7 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio
 			storage.Type = nextType // Support custom STORAGE_TYPE
 		}
 	}
-	overrides = append(overrides, sec)
+	overrides = append(overrides, defaultSec)
 
 	for _, override := range overrides {
 		for _, key := range override.Keys() {
@@ -76,6 +84,15 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio
 			storage.Type = override.Key("STORAGE_TYPE").String()
 		}
 	}
+
+	if storage.Type != "minio" && storage.Type != "local" {
+		customSec, err := rootCfg.GetSection(sectionName + "." + storage.Type)
+		if err == nil {
+			storage.Type = customSec.Key("STORAGE_TYPE").String()
+			storage.Section = customSec
+		}
+	}
+
 	storage.ServeDirect = storage.Section.Key("SERVE_DIRECT").MustBool(false)
 
 	// Specific defaults