From 75aa5cd4684d47d89866cd23dd9cb98ea1d5cb10 Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Fri, 26 May 2023 11:38:21 +0800 Subject: [PATCH 1/6] Add test to confirm storage could be inherit correctly --- modules/setting/attachment.go | 4 +++- modules/setting/attachment_test.go | 32 ++++++++++++++++++++++++++++++ modules/setting/packages.go | 7 +++++-- modules/setting/packages_test.go | 22 ++++++++++++++++++++ modules/setting/repository.go | 7 +++++++ modules/setting/repository_test.go | 32 ++++++++++++++++++++++++++++++ modules/setting/setting.go | 8 ++++++-- 7 files changed, 107 insertions(+), 5 deletions(-) create mode 100644 modules/setting/attachment_test.go create mode 100644 modules/setting/repository_test.go diff --git a/modules/setting/attachment.go b/modules/setting/attachment.go index 4d4b8e3b02430..4121fb87ae2be 100644 --- a/modules/setting/attachment.go +++ b/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 } diff --git a/modules/setting/attachment_test.go b/modules/setting/attachment_test.go new file mode 100644 index 0000000000000..9f30ea29b9bc2 --- /dev/null +++ b/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()) +} diff --git a/modules/setting/packages.go b/modules/setting/packages.go index 5e64d7fe9f7fc..a98b42da3cdef 100644 --- a/modules/setting/packages.go +++ b/modules/setting/packages.go @@ -4,6 +4,7 @@ package setting import ( + "fmt" "math" "net/url" "os" @@ -51,10 +52,10 @@ 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) @@ -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 { diff --git a/modules/setting/packages_test.go b/modules/setting/packages_test.go index d9f6e105287f0..315f150e15169 100644 --- a/modules/setting/packages_test.go +++ b/modules/setting/packages_test.go @@ -29,3 +29,25 @@ func TestMustBytes(t *testing.T) { assert.EqualValues(t, 1782579, test("1.7mib")) assert.EqualValues(t, -1, test("1 yib")) // too large } + +func Test_PackageStorage(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, loadPackagesFrom(cfg)) + storage := Packages.Storage + + assert.EqualValues(t, "minio", storage.Type) + assert.EqualValues(t, "gitea", storage.Section.Key("MINIO_BUCKET").String()) +} diff --git a/modules/setting/repository.go b/modules/setting/repository.go index 406068b59dd5d..4656497976772 100644 --- a/modules/setting/repository.go +++ b/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 } diff --git a/modules/setting/repository_test.go b/modules/setting/repository_test.go new file mode 100644 index 0000000000000..22a6725bdcf49 --- /dev/null +++ b/modules/setting/repository_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_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()) +} diff --git a/modules/setting/setting.go b/modules/setting/setting.go index 71cd9a12a99fd..a452be51efa35 100644 --- a/modules/setting/setting.go +++ b/modules/setting/setting.go @@ -222,12 +222,16 @@ func loadCommonSettingsFrom(cfg ConfigProvider) { loadOAuth2From(cfg) loadSecurityFrom(cfg) - loadAttachmentFrom(cfg) + if err := loadAttachmentFrom(cfg); err != nil { + log.Fatal("loadAttachmentFrom: %v", err) + } loadLFSFrom(cfg) loadTimeFrom(cfg) loadRepositoryFrom(cfg) loadPictureFrom(cfg) - loadPackagesFrom(cfg) + if err := loadPackagesFrom(cfg); err != nil { + log.Fatal("loadPackagesFrom: %v", err) + } loadActionsFrom(cfg) loadUIFrom(cfg) loadAdminFrom(cfg) From 97c9cae7a970434065507eb916f51c6b905ae69a Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Fri, 26 May 2023 12:30:13 +0800 Subject: [PATCH 2/6] test --- modules/setting/packages_test.go | 94 +++++++++++++++++++++++++++++- modules/setting/repository_test.go | 23 ++++++++ modules/setting/storage.go | 13 +++++ 3 files changed, 129 insertions(+), 1 deletion(-) diff --git a/modules/setting/packages_test.go b/modules/setting/packages_test.go index 315f150e15169..6b10b6ac5dbec 100644 --- a/modules/setting/packages_test.go +++ b/modules/setting/packages_test.go @@ -30,9 +30,13 @@ func TestMustBytes(t *testing.T) { assert.EqualValues(t, -1, test("1 yib")) // too large } -func Test_PackageStorage(t *testing.T) { +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 @@ -50,4 +54,92 @@ MINIO_SECRET_ACCESS_KEY = correct_key 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 = 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, "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 = 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, "packages/", storage.Section.Key("MINIO_BASE_PATH").String()) + assert.True(t, storage.Section.Key("SERVE_DIRECT").MustBool(false)) } diff --git a/modules/setting/repository_test.go b/modules/setting/repository_test.go index 22a6725bdcf49..c89f010ca7e81 100644 --- a/modules/setting/repository_test.go +++ b/modules/setting/repository_test.go @@ -29,4 +29,27 @@ MINIO_SECRET_ACCESS_KEY = correct_key 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()) } diff --git a/modules/setting/storage.go b/modules/setting/storage.go index 6da52807ecdc5..d07edaef56bcd 100644 --- a/modules/setting/storage.go +++ b/modules/setting/storage.go @@ -4,6 +4,7 @@ package setting import ( + "fmt" "path/filepath" "reflect" ) @@ -76,6 +77,16 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio storage.Type = override.Key("STORAGE_TYPE").String() } } + + if storage.Type != "minio" && storage.Type != "local" { + fmt.Println("=====111") + 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 @@ -86,5 +97,7 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio } storage.Section.Key("MINIO_BASE_PATH").MustString(name + "/") + + return storage } From 98344191341671dddb1c56f9c3312484a142a0ad Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sat, 3 Jun 2023 00:23:50 +0800 Subject: [PATCH 3/6] introduce initLoad for load setting --- modules/setting/setting.go | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/modules/setting/setting.go b/modules/setting/setting.go index a452be51efa35..30f405b3ad552 100644 --- a/modules/setting/setting.go +++ b/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,16 +232,12 @@ func loadCommonSettingsFrom(cfg ConfigProvider) { loadOAuth2From(cfg) loadSecurityFrom(cfg) - if err := loadAttachmentFrom(cfg); err != nil { - log.Fatal("loadAttachmentFrom: %v", err) - } + mustLoad(cfg, loadAttachmentFrom) loadLFSFrom(cfg) loadTimeFrom(cfg) loadRepositoryFrom(cfg) loadPictureFrom(cfg) - if err := loadPackagesFrom(cfg); err != nil { - log.Fatal("loadPackagesFrom: %v", err) - } + mustLoad(cfg, loadPackagesFrom) loadActionsFrom(cfg) loadUIFrom(cfg) loadAdminFrom(cfg) From 0c6906ca85a25f32b726a09749ab4a0f2ad9d52a Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Sun, 4 Jun 2023 13:59:52 +0800 Subject: [PATCH 4/6] Fix lint --- modules/setting/storage.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/modules/setting/storage.go b/modules/setting/storage.go index d07edaef56bcd..5562d42f5e665 100644 --- a/modules/setting/storage.go +++ b/modules/setting/storage.go @@ -4,7 +4,6 @@ package setting import ( - "fmt" "path/filepath" "reflect" ) @@ -79,7 +78,6 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio } if storage.Type != "minio" && storage.Type != "local" { - fmt.Println("=====111") customSec, err := rootCfg.GetSection(sectionName + "." + storage.Type) if err == nil { storage.Type = customSec.Key("STORAGE_TYPE").String() @@ -97,7 +95,5 @@ func getStorage(rootCfg ConfigProvider, name, typ string, targetSec ConfigSectio } storage.Section.Key("MINIO_BASE_PATH").MustString(name + "/") - - return storage } From 1af9448db63b182912f9b3371d1ddcc48b22dc92 Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Mon, 5 Jun 2023 21:53:28 +0800 Subject: [PATCH 5/6] Fix test --- modules/setting/packages.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/modules/setting/packages.go b/modules/setting/packages.go index a98b42da3cdef..6f3d9ad20a356 100644 --- a/modules/setting/packages.go +++ b/modules/setting/packages.go @@ -58,7 +58,7 @@ func loadPackagesFrom(rootCfg ConfigProvider) error { 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 From 15cd3d52b68f2c79f476180856c17cd13d446be7 Mon Sep 17 00:00:00 2001 From: Lunny Xiao Date: Tue, 6 Jun 2023 14:08:00 +0800 Subject: [PATCH 6/6] Fix test --- modules/setting/packages_test.go | 10 +++++----- modules/setting/storage.go | 28 ++++++++++++++++++---------- 2 files changed, 23 insertions(+), 15 deletions(-) diff --git a/modules/setting/packages_test.go b/modules/setting/packages_test.go index 6b10b6ac5dbec..93bd54553ed89 100644 --- a/modules/setting/packages_test.go +++ b/modules/setting/packages_test.go @@ -91,7 +91,7 @@ func Test_PackageStorage3(t *testing.T) { ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; [packages] STORAGE_TYPE = my_cfg -MINIO_BASE_PATH = packages/ +MINIO_BASE_PATH = my_packages/ SERVE_DIRECT = true [storage.my_cfg] @@ -111,7 +111,7 @@ MINIO_SECRET_ACCESS_KEY = correct_key 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.EqualValues(t, "my_packages/", storage.Section.Key("MINIO_BASE_PATH").String()) assert.True(t, storage.Section.Key("SERVE_DIRECT").MustBool(false)) } @@ -120,7 +120,7 @@ func Test_PackageStorage4(t *testing.T) { ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; [storage.packages] STORAGE_TYPE = my_cfg -MINIO_BASE_PATH = packages/ +MINIO_BASE_PATH = my_packages/ SERVE_DIRECT = true [storage.my_cfg] @@ -140,6 +140,6 @@ MINIO_SECRET_ACCESS_KEY = correct_key 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)) + assert.EqualValues(t, "my_packages/", storage.Section.Key("MINIO_BASE_PATH").String()) + assert.True(t, storage.ServeDirect) } diff --git a/modules/setting/storage.go b/modules/setting/storage.go index 5562d42f5e665..55774cf38bbf6 100644 --- a/modules/setting/storage.go +++ b/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() {