Feat/handle module definition

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, "/") {

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)
 }

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/<module-name>/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,14 +102,15 @@ func NewBasicModule(name, path string, order uint32, staticValues utils.Values,
 		},
 		hooks:                  newHooksStorage(),
 		keepTemporaryHookFiles: shapp.DebugKeepTmpFiles,
+		Config:                 config,
 	}
 
 	for _, opt := range opts {
 		opt.Apply(bmodule)
 	}
 
 	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

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{

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
+}

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()
 

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)
 	}