feat: support components to start in dependency order

Author: everfid-ever

pkg/console/component.go

@@ -51,6 +51,13 @@ type consoleWebServer struct {
 	cs     consolectx.Context
 }
 
+func (c *consoleWebServer) RequiredDependencies() []runtime.ComponentType {
+	return []runtime.ComponentType{
+		runtime.ResourceManager, // Console needs Manager for resource operations
+		// Note: No need to list ResourceStore explicitly as Manager already depends on it
+	}
+}
+
 func (c *consoleWebServer) Type() runtime.ComponentType {
 	return runtime.Console
 }

pkg/console/counter/component.go

@@ -38,6 +38,12 @@ type ManagerComponent interface {
 
 var _ ManagerComponent = &managerComponent{}
 
+func (cm *counterManager) RequiredDependencies() []runtime.ComponentType {
+	return []runtime.ComponentType{
+		runtime.ResourceStore,
+	}
+}
+
 type managerComponent struct {
 	manager CounterManager
 }

pkg/core/bootstrap/bootstrap.go

@@ -19,6 +19,8 @@ package bootstrap
 
 import (
 	"context"
+	"fmt"
+	"github.com/duke-git/lancet/v2/slice"
 
 	"github.com/pkg/errors"
 
@@ -34,45 +36,206 @@ func Bootstrap(appCtx context.Context, cfg app.AdminConfig) (runtime.Runtime, er
 	if err != nil {
 		return nil, err
 	}
-	// 0. initialize event bus
-	if err := initEventBus(builder); err != nil {
+
+	// Use smart bootstrapper for intelligent component initialization
+	bootstrapper := NewSmartBootstrapper(builder)
+
+	// Optional: Set bootstrap mode based on configuration
+	// bootstrapper.SetMode(StrictMode) // Uncomment for strict dependency checking
+
+	// Initialize all components in dependency order
+	if err := bootstrapper.bootstrapComponents(appCtx, cfg); err != nil {
 		return nil, err
 	}
-	// 1. initialize resource store
-	if err := initResourceStore(cfg, builder); err != nil {
+
+	// Build and return runtime
+	rt, err := builder.Build()
+	if err != nil {
 		return nil, err
 	}
-	// 2. initialize discovery
-	if err := initializeResourceDiscovery(builder); err != nil {
-		return nil, err
+	return rt, nil
+}
+
+// BootstrapMode defines how components are initialized
+type BootstrapMode int
+
+const (
+	// CompatibleMode uses dependency declarations when available, falls back to Order()
+	// This is the default mode for smooth migration
+	CompatibleMode BootstrapMode = iota
+
+	// StrictMode requires all components to declare dependencies, ignores Order()
+	// Use this mode for new development or after all components are migrated
+	StrictMode
+)
+
+// SmartBootstrapper handles intelligent component initialization
+type SmartBootstrapper struct {
+	builder *runtime.Builder
+	mode    BootstrapMode
+}
+
+// NewSmartBootstrapper creates a new smart bootstrapper
+func NewSmartBootstrapper(builder *runtime.Builder) *SmartBootstrapper {
+	return &SmartBootstrapper{
+		builder: builder,
+		mode:    CompatibleMode, // Default to compatible mode
 	}
-	// 3. initialize engine
-	if err := initializeResourceEngine(builder); err != nil {
-		return nil, err
+}
+
+// SetMode changes the bootstrap mode
+func (sb *SmartBootstrapper) SetMode(mode BootstrapMode) {
+	sb.mode = mode
+}
+
+// bootstrapComponents initializes all components in dependency order
+func (sb *SmartBootstrapper) bootstrapComponents(
+	ctx context.Context,
+	cfg app.AdminConfig,
+) error {
+	logger.Info("Starting smart component bootstrap...")
+
+	// Gather all components to initialize
+	components, err := sb.gatherComponents()
+	if err != nil {
+		return errors.Wrap(err, "failed to gather components")
 	}
-	// 4. initialize resource manager
-	if err := initResourceManager(builder); err != nil {
-		return nil, err
+
+	// Sort components by dependencies
+	ordered, err := sb.sortComponents(components)
+	if err != nil {
+		return errors.Wrap(err, "failed to sort components by dependencies")
 	}
-	// 5. initialize console
-	if err := initializeConsole(builder); err != nil {
-		return nil, err
+
+	// Initialize components in order
+	for i, comp := range ordered {
+		logger.Infof("[%d/%d] Initializing %s...", i+1, len(ordered), comp.Type())
+		if err := initAndActivateComponent(sb.builder, comp); err != nil {
+			return errors.Wrapf(err, "failed to initialize component %s", comp.Type())
+		}
+		logger.Infof("[%d/%d] %s initialized successfully", i+1, len(ordered), comp.Type())
 	}
-	// 6. initialize counter manager
-	if err := initializeCounterManager(builder); err != nil {
-		return nil, err
+
+	logger.Info("All components bootstrapped successfully")
+	return nil
+}
+
+// gatherComponents collects all components that need to be initialized
+func (sb *SmartBootstrapper) gatherComponents() ([]runtime.Component, error) {
+	components := []runtime.Component{}
+
+	// Core components
+	coreComps := []struct {
+		name   string
+		getter func() (runtime.Component, error)
+	}{
+		{"EventBus", runtime.ComponentRegistry().EventBus},
+		{"ResourceStore", runtime.ComponentRegistry().ResourceStore},
+		{"ResourceDiscovery", runtime.ComponentRegistry().ResourceDiscovery},
+		{"ResourceEngine", runtime.ComponentRegistry().ResourceEngine},
+		{"ResourceManager", runtime.ComponentRegistry().ResourceManager},
+		{"Console", runtime.ComponentRegistry().Console},
 	}
-	// 7. initialize diagnostics
-	if err := initializeDiagnoticsServer(builder); err != nil {
-		logger.Errorf("got error when init diagnotics server %s", err)
+
+	for _, comp := range coreComps {
+		c, err := comp.getter()
+		if err != nil {
+			return nil, errors.Wrapf(err, "failed to get component %s", comp.name)
+		}
+		components = append(components, c)
 	}
-	rt, err := builder.Build()
+
+	// Optional components
+	optionalComps := []struct {
+		name string
+		typ  runtime.ComponentType
+	}{
+		{"CounterManager", counter.ComponentType},
+		{"DiagnosticsServer", diagnostics.DiagnosticsServer},
+	}
+
+	for _, comp := range optionalComps {
+		c, err := runtime.ComponentRegistry().Get(comp.typ)
+		if err != nil {
+			logger.Warnf("Optional component %s not available: %v", comp.name, err)
+			continue
+		}
+		components = append(components, c)
+	}
+
+	return components, nil
+}
+
+// sortComponents sorts components by dependency order
+func (sb *SmartBootstrapper) sortComponents(
+	components []runtime.Component,
+) ([]runtime.Component, error) {
+	// Categorize components
+	withDeps := []runtime.ComponentWithDependencies{}
+	withoutDeps := []runtime.Component{}
+
+	for _, comp := range components {
+		if dep, ok := comp.(runtime.ComponentWithDependencies); ok {
+			withDeps = append(withDeps, dep)
+			logger.Debugf("Component %s declares dependencies: %v",
+				comp.Type(), dep.RequiredDependencies())
+		} else {
+			withoutDeps = append(withoutDeps, comp)
+			logger.Debugf("Component %s uses Order() mode: %d",
+				comp.Type(), comp.Order())
+		}
+	}
+
+	// If no components declare dependencies, fall back to Order() sorting
+	if len(withDeps) == 0 {
+		logger.Info("No components declare dependencies, using Order() based initialization")
+		return sortByOrder(components), nil
+	}
+
+	// In strict mode, all components must declare dependencies
+	if sb.mode == StrictMode && len(withoutDeps) > 0 {
+		names := []string{}
+		for _, comp := range withoutDeps {
+			names = append(names, string(comp.Type()))
+		}
+		return nil, fmt.Errorf(
+			"strict mode enabled but the following components don't declare dependencies: %v\n"+
+				"Please implement RequiredDependencies() for these components",
+			names,
+		)
+	}
+
+	// Build dependency graph and perform topological sort
+	graph := runtime.NewDependencyGraph(components)
+	sorted, err := graph.TopologicalSort()
 	if err != nil {
 		return nil, err
 	}
-	return rt, nil
+
+	// Log initialization order
+	logger.Info("Component initialization order:")
+	for i, comp := range sorted {
+		logger.Infof("  %d. %s", i+1, comp.Type())
+	}
+
+	return sorted, nil
 }
 
+// sortByOrder sorts components by Order() value (legacy mode)
+func sortByOrder(components []runtime.Component) []runtime.Component {
+	sorted := make([]runtime.Component, len(components))
+	copy(sorted, components)
+
+	slice.SortBy(sorted, func(a, b runtime.Component) bool {
+		return a.Order() > b.Order()
+	})
+
+	return sorted
+}
+
+// Legacy functions below are kept for reference but no longer used
+// They can be removed in a future version after all components are migrated
+
 func initEventBus(builder *runtime.Builder) error {
 	comp, err := runtime.ComponentRegistry().EventBus()
 	if err != nil {

pkg/core/discovery/component.go

@@ -57,6 +57,13 @@ type discoveryComponent struct {
 	subscriptionMgr events.SubscriptionManager
 }
 
+func (d *discoveryComponent) RequiredDependencies() []runtime.ComponentType {
+	return []runtime.ComponentType{
+		runtime.EventBus,      // Discovery needs EventBus for event emission
+		runtime.ResourceStore, // Discovery needs Store for resource storage
+	}
+}
+
 func newDiscoveryComponent() Component {
 	return &discoveryComponent{
 		informers:   make(map[string]Informers),

pkg/core/events/component.go

@@ -43,6 +43,10 @@ type eventBus struct {
 	subscriberDir map[model.ResourceKind]Subscribers
 }
 
+func (b *eventBus) RequiredDependencies() []runtime.ComponentType {
+	return nil // EventBus has no dependencies
+}
+
 func (b *eventBus) Type() runtime.ComponentType {
 	return runtime.EventBus
 }

pkg/core/manager/component.go

@@ -41,6 +41,12 @@ type resourceManagerComponent struct {
 	rm ResourceManager
 }
 
+func (r *resourceManagerComponent) RequiredDependencies() []runtime.ComponentType {
+	return []runtime.ComponentType{
+		runtime.ResourceStore, // Manager needs Store to be initialized first
+	}
+}
+
 func (r *resourceManagerComponent) Type() runtime.ComponentType {
 	return runtime.ResourceManager
 }

pkg/core/runtime/component.go

@@ -42,6 +42,7 @@ type Attribute interface {
 	// Type returns the type of the component
 	Type() ComponentType
 	// Order indicates the order of the component during bootstrap, the bigger will be started first
+	// Deprecated: Use RequiredDependencies() instead for explicit dependency management
 	Order() int
 }
 
@@ -52,6 +53,21 @@ type Component interface {
 	Lifecycle
 }
 
+// Dependency declares component dependencies
+// Components implementing this interface will be initialized in dependency order
+type Dependency interface {
+	// RequiredDependencies returns the component types that must be initialized before this component
+	// The system will ensure all required dependencies are initialized first, or fail with a clear error
+	RequiredDependencies() []ComponentType
+}
+
+// ComponentWithDependencies is a component that explicitly declares its dependencies
+// This is the recommended way to define component initialization order
+type ComponentWithDependencies interface {
+	Component
+	Dependency
+}
+
 // GracefulComponent is a component that supports waiting until it's finished.
 // It's useful if there is cleanup logic that has to be executed before the process exits
 // (i.e. sending SIGTERM signals to subprocesses started by this component).
@@ -70,3 +86,13 @@ type ComponentManager interface {
 	// Start starts all components.
 	Start(<-chan struct{}) error
 }
+
+// BaseComponent provides default implementations for optional interfaces
+// Components can embed this struct to get default implementations
+type BaseComponent struct{}
+
+// RequiredDependencies returns nil, indicating no dependencies
+// Components can override this method to declare their dependencies
+func (b *BaseComponent) RequiredDependencies() []ComponentType {
+	return nil
+}