diff --git a/pkg/module_manager/loader/fs/fs.go b/pkg/module_manager/loader/fs/fs.go index 6aaae65ef..2d1cd4d74 100644 --- a/pkg/module_manager/loader/fs/fs.go +++ b/pkg/module_manager/loader/fs/fs.go @@ -66,7 +66,7 @@ func (fl *FileSystemLoader) getBasicModule(definition moduleDefinition, commonSt return nil, fmt.Errorf("expect map[string]interface{} in module values") } - m, err := modules.NewBasicModule(definition.Name, definition.Path, definition.Order, moduleValues, cb, vb, modules.WithLogger(fl.logger.Named("basic-module"))) + m, err := modules.NewBasicModule(&modules.Config{Name: definition.Name, Path: definition.Path, Weight: definition.Order}, moduleValues, cb, vb, modules.WithLogger(fl.logger.Named("basic-module"))) if err != nil { return nil, fmt.Errorf("new basic module: %w", err) } @@ -75,7 +75,7 @@ func (fl *FileSystemLoader) getBasicModule(definition moduleDefinition, commonSt } // LoadModule reads single directory and returns BasicModule -func (fl *FileSystemLoader) LoadModule(_, modulePath string) (*modules.BasicModule, error) { +func (fl *FileSystemLoader) LoadModule(modulePath string) (*modules.BasicModule, error) { // the module's parent directory var modulesDir string if strings.HasSuffix(modulePath, "/") { diff --git a/pkg/module_manager/loader/loader.go b/pkg/module_manager/loader/loader.go index 3f76cd26c..6cbc1d6b5 100644 --- a/pkg/module_manager/loader/loader.go +++ b/pkg/module_manager/loader/loader.go @@ -6,5 +6,5 @@ import ( type ModuleLoader interface { LoadModules() ([]*modules.BasicModule, error) - LoadModule(moduleSource string, modulePath string) (*modules.BasicModule, error) + LoadModule(modulePath string) (*modules.BasicModule, error) } diff --git a/pkg/module_manager/models/modules/basic.go b/pkg/module_manager/models/modules/basic.go index f3f9cfdef..3ec3ae305 100644 --- a/pkg/module_manager/models/modules/basic.go +++ b/pkg/module_manager/models/modules/basic.go @@ -71,22 +71,27 @@ type BasicModule struct { l sync.RWMutex state *moduleState + + Config *Config } -// TODO: add options WithLogger // NewBasicModule creates new BasicModule // staticValues - are values from modules/values.yaml and /modules//values.yaml, they could not be changed during the runtime -func NewBasicModule(name, path string, order uint32, staticValues utils.Values, configBytes, valuesBytes []byte, opts ...ModuleOption) (*BasicModule, error) { - valuesStorage, err := NewValuesStorage(name, staticValues, configBytes, valuesBytes) +func NewBasicModule(config *Config, staticValues utils.Values, configBytes, valuesBytes []byte, opts ...ModuleOption) (*BasicModule, error) { + if config == nil { + return nil, errors.New("module configuration is nil") + } + + valuesStorage, err := NewValuesStorage(config.Name, staticValues, configBytes, valuesBytes) if err != nil { return nil, fmt.Errorf("new values storage: %w", err) } - crdsFromPath := getCRDsFromPath(path, app.CRDsFilters) + crdsFromPath := getCRDsFromPath(config.Path, app.CRDsFilters) bmodule := &BasicModule{ - Name: name, - Order: order, - Path: path, + Name: config.Name, + Order: config.Weight, + Path: config.Path, crdsExist: len(crdsFromPath) > 0, crdFilesPaths: crdsFromPath, valuesStorage: valuesStorage, @@ -97,6 +102,7 @@ func NewBasicModule(name, path string, order uint32, staticValues utils.Values, }, hooks: newHooksStorage(), keepTemporaryHookFiles: shapp.DebugKeepTmpFiles, + Config: config, } for _, opt := range opts { @@ -104,7 +110,7 @@ func NewBasicModule(name, path string, order uint32, staticValues utils.Values, } if bmodule.logger == nil { - bmodule.logger = log.NewLogger(log.Options{}).Named("basic-module").Named(name) + bmodule.logger = log.NewLogger(log.Options{}).Named("basic-module").Named(config.Name) } return bmodule, nil diff --git a/pkg/module_manager/models/modules/basic_test.go b/pkg/module_manager/models/modules/basic_test.go index 966c4876c..189ad9759 100644 --- a/pkg/module_manager/models/modules/basic_test.go +++ b/pkg/module_manager/models/modules/basic_test.go @@ -19,7 +19,7 @@ foo: ` value, err := utils.NewValuesFromBytes([]byte(valuesStr)) require.NoError(t, err) - bm, err := NewBasicModule("test-1", "/tmp/test", 100, value, nil, nil) + bm, err := NewBasicModule(&Config{Name: "test-1", Path: "/tmp/test", Weight: 100}, value, nil, nil) require.NoError(t, err) patch := utils.ValuesPatch{Operations: []*sdkutils.ValuesPatchOperation{ diff --git a/pkg/module_manager/models/modules/config.go b/pkg/module_manager/models/modules/config.go new file mode 100644 index 000000000..4119c33ba --- /dev/null +++ b/pkg/module_manager/models/modules/config.go @@ -0,0 +1,73 @@ +package modules + +type Config struct { + // required fields + // parameters used by addon operator + Name string + Weight uint32 + Path string + + Tags []string + Subsystems []string + Namespace string + Stage string + ExclusiveGroup string + + Descriptions *ModuleDescriptions + Requirements *ModuleRequirements + + DisableOptions *ModuleDisableOptions + + Accessibility *Accessibility +} + +type ModuleDescriptions struct { + Ru string + En string +} + +type ModuleRequirements struct { + ModulePlatformRequirements + ParentModules map[string]string +} + +type ModulePlatformRequirements struct { + Deckhouse string + Kubernetes string + Bootstrapped string +} + +type ModuleDisableOptions struct { + Confirmation bool + Message string +} + +type Bundle string + +type FeatureFlag string + +type Batch struct { + Available bool + Enabled bool + FeatureFlags []FeatureFlag +} + +type Batches map[string]Batch + +type Edition struct { + Available bool + EnabledInBundles []Bundle + FeatureFlags []FeatureFlag +} + +type Editions struct { + Default *Edition + Ee *Edition + Se *Edition + Be *Edition +} + +type Accessibility struct { + Batches *Batches + Editions *Editions +} diff --git a/pkg/module_manager/models/moduleset/moduleset_test.go b/pkg/module_manager/models/moduleset/moduleset_test.go index ff1ef96a2..4b1fe64a0 100644 --- a/pkg/module_manager/models/moduleset/moduleset_test.go +++ b/pkg/module_manager/models/moduleset/moduleset_test.go @@ -15,27 +15,51 @@ func TestBasicModuleSet(t *testing.T) { ms.Add(&modules.BasicModule{ Name: "BasicModule-two", Order: 10, + Config: &modules.Config{ + Name: "BasicModule-two", + Weight: 10, + }, }) ms.Add(&modules.BasicModule{ Name: "BasicModule-one", Order: 5, + Config: &modules.Config{ + Name: "BasicModule-one", + Weight: 5, + }, }) ms.Add(&modules.BasicModule{ Name: "BasicModule-three-two", Order: 15, + Config: &modules.Config{ + Name: "BasicModule-three-two", + Weight: 15, + }, }) ms.Add(&modules.BasicModule{ Name: "BasicModule-four", Order: 1, + Config: &modules.Config{ + Name: "BasicModule-four", + Weight: 1, + }, }) ms.Add(&modules.BasicModule{ Name: "BasicModule-three-one", Order: 15, + Config: &modules.Config{ + Name: "BasicModule-three-one", + Weight: 15, + }, }) // "overridden" BasicModule ms.Add(&modules.BasicModule{ Name: "BasicModule-four", Order: 20, + Config: &modules.Config{ + Name: "BasicModule-four", + Weight: 20, + }, }) ms.SetInited() diff --git a/pkg/module_manager/module_manager.go b/pkg/module_manager/module_manager.go index 770588599..a6f97cc61 100644 --- a/pkg/module_manager/module_manager.go +++ b/pkg/module_manager/module_manager.go @@ -1156,13 +1156,13 @@ func (mm *ModuleManager) AreModulesInited() bool { } // RunModuleWithNewOpenAPISchema updates the module's OpenAPI schema from modulePath directory and pushes RunModuleTask if the module is enabled -func (mm *ModuleManager) RunModuleWithNewOpenAPISchema(moduleName, moduleSource, modulePath string) error { +func (mm *ModuleManager) RunModuleWithNewOpenAPISchema(moduleName, modulePath string) error { currentModule := mm.modules.Get(moduleName) if currentModule == nil { return fmt.Errorf("failed to get basic module - not found") } - basicModule, err := mm.moduleLoader.LoadModule(moduleSource, modulePath) + basicModule, err := mm.moduleLoader.LoadModule(modulePath) if err != nil { return fmt.Errorf("load module: %w", err) }