Modules: Add registry (#70859)

pkg/modules/modules.go

@@ -11,11 +11,6 @@ import (
 	"github.com/grafana/grafana/pkg/setting"
 )
 
-// List of available targets.
-const (
-	All string = "all"
-)
-
 type Engine interface {
 	Init(context.Context) error
 	Run(context.Context) error
@@ -23,8 +18,8 @@ type Engine interface {
 }
 
 type Manager interface {
-	RegisterModule(name string, initFn func() (services.Service, error), deps ...string)
-	RegisterInvisibleModule(name string, initFn func() (services.Service, error), deps ...string)
+	RegisterModule(name string, initFn func() (services.Service, error))
+	RegisterInvisibleModule(name string, initFn func() (services.Service, error))
 }
 
 var _ Engine = (*service)(nil)
@@ -32,27 +27,25 @@ var _ Manager = (*service)(nil)
 
 // service manages the registration and lifecycle of modules.
 type service struct {
-	cfg           *setting.Cfg
-	log           log.Logger
-	targets       []string
-	dependencyMap map[string][]string
+	cfg     *setting.Cfg
+	log     log.Logger
+	targets []string
 
-	ModuleManager  *modules.Manager
-	ServiceManager *services.Manager
-	ServiceMap     map[string]services.Service
+	moduleManager  *modules.Manager
+	serviceManager *services.Manager
+	serviceMap     map[string]services.Service
 }
 
 func ProvideService(cfg *setting.Cfg) *service {
 	logger := log.New("modules")
 
 	return &service{
-		cfg:           cfg,
-		log:           logger,
-		targets:       cfg.Target,
-		dependencyMap: map[string][]string{},
+		cfg:     cfg,
+		log:     logger,
+		targets: cfg.Target,
 
-		ModuleManager: modules.NewManager(logger),
-		ServiceMap:    map[string]services.Service{},
+		moduleManager: modules.NewManager(logger),
+		serviceMap:    map[string]services.Service{},
 	}
 }
 
@@ -60,30 +53,27 @@ func ProvideService(cfg *setting.Cfg) *service {
 func (m *service) Init(_ context.Context) error {
 	var err error
 
-	// module registration
-	m.RegisterModule(All, nil)
-
-	for mod, targets := range m.dependencyMap {
-		if err := m.ModuleManager.AddDependency(mod, targets...); err != nil {
+	for mod, targets := range dependencyMap {
+		if err := m.moduleManager.AddDependency(mod, targets...); err != nil {
 			return err
 		}
 	}
 
-	m.ServiceMap, err = m.ModuleManager.InitModuleServices(m.targets...)
+	m.serviceMap, err = m.moduleManager.InitModuleServices(m.targets...)
 	if err != nil {
 		return err
 	}
 
 	// if no modules are registered, we don't need to start the service manager
-	if len(m.ServiceMap) == 0 {
+	if len(m.serviceMap) == 0 {
 		return nil
 	}
 
 	var svcs []services.Service
-	for _, s := range m.ServiceMap {
+	for _, s := range m.serviceMap {
 		svcs = append(svcs, s)
 	}
-	m.ServiceManager, err = services.NewManager(svcs...)
+	m.serviceManager, err = services.NewManager(svcs...)
 
 	return err
 }
@@ -93,27 +83,27 @@ func (m *service) Run(ctx context.Context) error {
 	// we don't need to continue if no modules are registered.
 	// this behavior may need to change if dskit services replace the
 	// current background service registry.
-	if len(m.ServiceMap) == 0 {
+	if len(m.serviceMap) == 0 {
 		m.log.Warn("No modules registered...")
 		<-ctx.Done()
 		return nil
 	}
 
 	listener := newServiceListener(m.log, m)
-	m.ServiceManager.AddListener(listener)
+	m.serviceManager.AddListener(listener)
 
 	// wait until a service fails or stop signal was received
-	err := m.ServiceManager.StartAsync(ctx)
+	err := m.serviceManager.StartAsync(ctx)
 	if err != nil {
 		return err
 	}
 
-	err = m.ServiceManager.AwaitStopped(ctx)
+	err = m.serviceManager.AwaitStopped(ctx)
 	if err != nil {
 		return err
 	}
 
-	failed := m.ServiceManager.ServicesByState()[services.Failed]
+	failed := m.serviceManager.ServicesByState()[services.Failed]
 	for _, f := range failed {
 		// the service listener will log error details for all modules that failed,
 		// so here we return the first error that is not ErrStopProcess
@@ -127,26 +117,24 @@ func (m *service) Run(ctx context.Context) error {
 
 // Shutdown stops all modules and waits for them to stop.
 func (m *service) Shutdown(ctx context.Context) error {
-	if m.ServiceManager == nil {
+	if m.serviceManager == nil {
 		m.log.Debug("No modules registered, nothing to stop...")
 		return nil
 	}
-	m.ServiceManager.StopAsync()
+	m.serviceManager.StopAsync()
 	m.log.Info("Awaiting services to be stopped...")
-	return m.ServiceManager.AwaitStopped(ctx)
+	return m.serviceManager.AwaitStopped(ctx)
 }
 
 // RegisterModule registers a module with the dskit module manager.
-func (m *service) RegisterModule(name string, initFn func() (services.Service, error), deps ...string) {
-	m.ModuleManager.RegisterModule(name, initFn)
-	m.dependencyMap[name] = deps
+func (m *service) RegisterModule(name string, initFn func() (services.Service, error)) {
+	m.moduleManager.RegisterModule(name, initFn)
 }
 
 // RegisterInvisibleModule registers an invisible module with the dskit module manager.
-// Invisible modules are not visible to the user, and are intendent to be used as dependencies.
-func (m *service) RegisterInvisibleModule(name string, initFn func() (services.Service, error), deps ...string) {
-	m.ModuleManager.RegisterModule(name, initFn, modules.UserInvisibleModule)
-	m.dependencyMap[name] = deps
+// Invisible modules are not visible to the user, and are intended to be used as dependencies.
+func (m *service) RegisterInvisibleModule(name string, initFn func() (services.Service, error)) {
+	m.moduleManager.RegisterModule(name, initFn, modules.UserInvisibleModule)
 }
 
 // IsModuleEnabled returns true if the module is enabled.