refactor(server/v2): eager config loading

runtime/config.go

@@ -0,0 +1,46 @@
+package runtime
+
+import (
+	"cosmossdk.io/core/server"
+	"cosmossdk.io/depinject"
+)
+
+// ModuleConfigMaps is a map module scoped ConfigMaps
+type ModuleConfigMaps map[string]server.ConfigMap
+
+type ModuleConfigMapsInput struct {
+	depinject.In
+
+	ModuleConfigs []server.ModuleConfigMap
+	DynamicConfig server.DynamicConfig `optional:"true"`
+}
+
+// ProvideModuleConfigMaps returns a map of module name to module config map.
+// The module config map is a map of flag to value.
+func ProvideModuleConfigMaps(in ModuleConfigMapsInput) ModuleConfigMaps {
+	moduleConfigMaps := make(ModuleConfigMaps)
+	if in.DynamicConfig == nil {
+		return moduleConfigMaps
+	}
+	for _, moduleConfig := range in.ModuleConfigs {
+		cfg := moduleConfig.Config
+		name := moduleConfig.Module
+		moduleConfigMaps[name] = make(server.ConfigMap)
+		for flag, df := range cfg {
+			val := in.DynamicConfig.Get(flag)
+			if val != nil {
+				moduleConfigMaps[name][flag] = val
+			} else {
+				moduleConfigMaps[name][flag] = df
+			}
+		}
+	}
+	return moduleConfigMaps
+}
+
+func ProvideModuleScopedConfigMap(
+	key depinject.ModuleKey,
+	moduleConfigs ModuleConfigMaps,
+) server.ConfigMap {
+	return moduleConfigs[key.Name()]
+}

runtime/module.go

@@ -103,6 +103,8 @@ func init() {
 			ProvideTransientStoreService,
 			ProvideModuleManager,
 			ProvideCometService,
+			ProvideModuleConfigMaps,
+			ProvideModuleScopedConfigMap,
 		),
 		appconfig.Invoke(SetupAppBuilder),
 	)

runtime/v2/app.go

@@ -83,7 +83,7 @@ func (a *App[T]) LoadLatestHeight() (uint64, error) {
 	return a.db.GetLatestVersion()
 }
 
-// GetQueryHandlers returns the query handlers.
+// QueryHandlers returns the query handlers.
 func (a *App[T]) QueryHandlers() map[string]appmodulev2.Handler {
 	return a.queryHandlers
 }

runtime/v2/builder.go

@@ -24,6 +24,7 @@ import (
 type AppBuilder[T transaction.Tx] struct {
 	app          *App[T]
 	storeBuilder root.Builder
+	storeConfig  *root.Config
 
 	// the following fields are used to overwrite the default
 	branch      func(state store.ReaderMap) store.WriterMap
@@ -82,12 +83,13 @@ func (a *AppBuilder[T]) Build(opts ...AppBuilderOption[T]) (*App[T], error) {
 		}
 	}
 
-	a.app.db = a.storeBuilder.Get()
-	if a.app.db == nil {
-		return nil, fmt.Errorf("storeBuilder did not return a db")
+	var err error
+	a.app.db, err = a.storeBuilder.Build(a.app.logger, a.storeConfig)
+	if err != nil {
+		return nil, err
 	}
 
-	if err := a.app.moduleManager.RegisterServices(a.app); err != nil {
+	if err = a.app.moduleManager.RegisterServices(a.app); err != nil {
 		return nil, err
 	}
 

runtime/v2/config.go

@@ -0,0 +1,59 @@
+package runtime
+
+import (
+	"strings"
+
+	"cosmossdk.io/core/server"
+	"cosmossdk.io/depinject"
+)
+
+// GlobalConfig is a recursive configuration map containing configuration
+// key-value pairs parsed from the configuration file, flags, or other
+// input sources.
+type GlobalConfig server.ConfigMap
+
+// ModuleConfigMaps is a map module scoped ConfigMaps
+type ModuleConfigMaps map[string]server.ConfigMap
+
+// ProvideModuleConfigMaps returns a map of module name to module config map.
+// The module config map is a map of flag to value.
+func ProvideModuleConfigMaps(
+	moduleConfigs []server.ModuleConfigMap,
+	globalConfig GlobalConfig,
+) ModuleConfigMaps {
+	moduleConfigMaps := make(ModuleConfigMaps)
+	for _, moduleConfig := range moduleConfigs {
+		cfg := moduleConfig.Config
+		name := moduleConfig.Module
+		moduleConfigMaps[name] = make(server.ConfigMap)
+		for flag, df := range cfg {
+			m := globalConfig
+			fetchFlag := flag
+			for _, part := range strings.Split(flag, ".") {
+				if maybeMap, ok := m[part]; ok {
+					innerMap, ok := maybeMap.(map[string]any)
+					if !ok {
+						fetchFlag = part
+						break
+					}
+					m = innerMap
+				} else {
+					break
+				}
+			}
+			if val, ok := m[fetchFlag]; ok {
+				moduleConfigMaps[name][flag] = val
+			} else {
+				moduleConfigMaps[name][flag] = df
+			}
+		}
+	}
+	return moduleConfigMaps
+}
+
+func ProvideModuleScopedConfigMap(
+	key depinject.ModuleKey,
+	moduleConfigs ModuleConfigMaps,
+) server.ConfigMap {
+	return moduleConfigs[key.Name()]
+}

runtime/v2/module.go

@@ -99,6 +99,8 @@ func init() {
 			ProvideModuleManager[transaction.Tx],
 			ProvideEnvironment,
 			ProvideKVService,
+			ProvideModuleConfigMaps,
+			ProvideModuleScopedConfigMap,
 		),
 		appconfig.Invoke(SetupAppBuilder),
 	)
@@ -108,6 +110,7 @@ func ProvideAppBuilder[T transaction.Tx](
 	interfaceRegistrar registry.InterfaceRegistrar,
 	amino registry.AminoRegistrar,
 	storeBuilder root.Builder,
+	storeConfig *root.Config,
 ) (
 	*AppBuilder[T],
 	*stf.MsgRouterBuilder,
@@ -134,14 +137,15 @@ func ProvideAppBuilder[T transaction.Tx](
 		queryHandlers:      map[string]appmodulev2.Handler{},
 		storeLoader:        DefaultStoreLoader,
 	}
-	appBuilder := &AppBuilder[T]{app: app, storeBuilder: storeBuilder}
+	appBuilder := &AppBuilder[T]{app: app, storeBuilder: storeBuilder, storeConfig: storeConfig}
 
 	return appBuilder, msgRouterBuilder, appModule[T]{app}, protoFiles, protoTypes
 }
 
 type AppInputs struct {
 	depinject.In
 
+	StoreConfig        *root.Config
 	Config             *runtimev2.Module
 	AppBuilder         *AppBuilder[transaction.Tx]
 	ModuleManager      *MM[transaction.Tx]

server/v2/api/grpc/server.go

@@ -21,6 +21,7 @@ import (
 	"google.golang.org/protobuf/reflect/protoreflect"
 
 	appmodulev2 "cosmossdk.io/core/appmodule/v2"
+	"cosmossdk.io/core/server"
 	"cosmossdk.io/core/transaction"
 	"cosmossdk.io/log"
 	serverv2 "cosmossdk.io/server/v2"
@@ -42,40 +43,50 @@ type Server[T transaction.Tx] struct {
 }
 
 // New creates a new grpc server.
-func New[T transaction.Tx](cfgOptions ...CfgOption) *Server[T] {
-	return &Server[T]{
+func New[T transaction.Tx](
+	logger log.Logger,
+	interfaceRegistry server.InterfaceRegistry,
+	queryHandlers map[string]appmodulev2.Handler,
+	queryable interface {
+		Query(ctx context.Context, version uint64, msg transaction.Msg) (transaction.Msg, error)
+	},
+	cfg server.ConfigMap,
+	cfgOptions ...CfgOption,
+) (*Server[T], error) {
+	srv := &Server[T]{
 		cfgOptions: cfgOptions,
 	}
-}
-
-// Init returns a correctly configured and initialized gRPC server.
-// Note, the caller is responsible for starting the server.
-func (s *Server[T]) Init(appI serverv2.AppI[T], cfg map[string]any, logger log.Logger) error {
-	serverCfg := s.Config().(*Config)
+	serverCfg := srv.Config().(*Config)
 	if len(cfg) > 0 {
-		if err := serverv2.UnmarshalSubConfig(cfg, s.Name(), &serverCfg); err != nil {
-			return fmt.Errorf("failed to unmarshal config: %w", err)
+		if err := serverv2.UnmarshalSubConfig(cfg, srv.Name(), &serverCfg); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal config: %w", err)
 		}
 	}
-	methodsMap := appI.QueryHandlers()
 
 	grpcSrv := grpc.NewServer(
-		grpc.ForceServerCodec(newProtoCodec(appI.InterfaceRegistry()).GRPCCodec()),
+		grpc.ForceServerCodec(newProtoCodec(interfaceRegistry).GRPCCodec()),
 		grpc.MaxSendMsgSize(serverCfg.MaxSendMsgSize),
 		grpc.MaxRecvMsgSize(serverCfg.MaxRecvMsgSize),
-		grpc.UnknownServiceHandler(
-			makeUnknownServiceHandler(methodsMap, appI),
-		),
+		grpc.UnknownServiceHandler(makeUnknownServiceHandler(queryHandlers, queryable)),
 	)
 
 	// Reflection allows external clients to see what services and methods the gRPC server exposes.
-	gogoreflection.Register(grpcSrv, slices.Collect(maps.Keys(methodsMap)), logger.With("sub-module", "grpc-reflection"))
+	gogoreflection.Register(grpcSrv, slices.Collect(maps.Keys(queryHandlers)), logger.With("sub-module", "grpc-reflection"))
 
-	s.grpcSrv = grpcSrv
-	s.config = serverCfg
-	s.logger = logger.With(log.ModuleKey, s.Name())
+	srv.grpcSrv = grpcSrv
+	srv.config = serverCfg
+	srv.logger = logger.With(log.ModuleKey, srv.Name())
 
-	return nil
+	return srv, nil
+}
+
+// NewWithConfigOptions creates a new GRPC server with the provided config options.
+// It is *not* a fully functional server (since it has been created without dependencies)
+// The returned server should only be used to get and set configuration.
+func NewWithConfigOptions[T transaction.Tx](opts ...CfgOption) *Server[T] {
+	return &Server[T]{
+		cfgOptions: opts,
+	}
 }
 
 func (s *Server[T]) StartCmdFlags() *pflag.FlagSet {
@@ -186,7 +197,7 @@ func (s *Server[T]) Config() any {
 	return s.config
 }
 
-func (s *Server[T]) Start(ctx context.Context) error {
+func (s *Server[T]) Start(context.Context) error {
 	if !s.config.Enable {
 		s.logger.Info(fmt.Sprintf("%s server is disabled via config", s.Name()))
 		return nil

server/v2/api/grpcgateway/server.go

@@ -80,22 +80,6 @@ func (s *Server[T]) Config() any {
 	return s.config
 }
 
-func (s *Server[T]) Init(appI serverv2.AppI[transaction.Tx], cfg map[string]any, logger log.Logger) error {
-	serverCfg := s.Config().(*Config)
-	if len(cfg) > 0 {
-		if err := serverv2.UnmarshalSubConfig(cfg, s.Name(), &serverCfg); err != nil {
-			return fmt.Errorf("failed to unmarshal config: %w", err)
-		}
-	}
-
-	// TODO: register the gRPC-Gateway routes
-
-	s.logger = logger.With(log.ModuleKey, s.Name())
-	s.config = serverCfg
-
-	return nil
-}
-
 func (s *Server[T]) Start(ctx context.Context) error {
 	if !s.config.Enable {
 		s.logger.Info(fmt.Sprintf("%s server is disabled via config", s.Name()))

server/v2/api/rest/server.go

@@ -6,9 +6,11 @@ import (
 	"fmt"
 	"net/http"
 
+	"cosmossdk.io/core/server"
 	"cosmossdk.io/core/transaction"
 	"cosmossdk.io/log"
 	serverv2 "cosmossdk.io/server/v2"
+	"cosmossdk.io/server/v2/appmanager"
 )
 
 const (
@@ -24,31 +26,42 @@ type Server[T transaction.Tx] struct {
 	cfgOptions []CfgOption
 }
 
-func New[T transaction.Tx](cfgOptions ...CfgOption) *Server[T] {
-	return &Server[T]{
+func New[T transaction.Tx](
+	appManager appmanager.AppManager[T],
+	logger log.Logger,
+	cfg server.ConfigMap,
+	cfgOptions ...CfgOption,
+) (*Server[T], error) {
+	srv := &Server[T]{
 		cfgOptions: cfgOptions,
+		logger:     logger.With(log.ModuleKey, ServerName),
+		router:     http.NewServeMux(),
 	}
-}
 
-func (s *Server[T]) Name() string {
-	return ServerName
-}
-
-func (s *Server[T]) Init(appI serverv2.AppI[T], cfg map[string]any, logger log.Logger) error {
-	s.logger = logger.With(log.ModuleKey, s.Name())
+	srv.router.Handle("/", NewDefaultHandler(appManager))
 
-	serverCfg := s.Config().(*Config)
+	serverCfg := srv.Config().(*Config)
 	if len(cfg) > 0 {
-		if err := serverv2.UnmarshalSubConfig(cfg, s.Name(), &serverCfg); err != nil {
-			return fmt.Errorf("failed to unmarshal config: %w", err)
+		if err := serverv2.UnmarshalSubConfig(cfg, srv.Name(), &serverCfg); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal config: %w", err)
 		}
 	}
+	srv.config = serverCfg
+
+	return srv, nil
+}
 
-	s.router = http.NewServeMux()
-	s.router.Handle("/", NewDefaultHandler(appI))
-	s.config = serverCfg
+// NewWithConfigOptions creates a new REST server with the provided config options.
+// It is *not* a fully functional server (since it has been created without dependencies)
+// The returned server should only be used to get and set configuration.
+func NewWithConfigOptions[T transaction.Tx](opts ...CfgOption) *Server[T] {
+	return &Server[T]{
+		cfgOptions: opts,
+	}
+}
 
-	return nil
+func (s *Server[T]) Name() string {
+	return ServerName
 }
 
 func (s *Server[T]) Start(ctx context.Context) error {

server/v2/api/rest/server_test.go

@@ -17,15 +17,15 @@ func TestServerConfig(t *testing.T) {
 		{
 			name: "Default configuration, no custom configuration",
 			setupFunc: func() *Config {
-				s := New[transaction.Tx]()
+				s := &Server[transaction.Tx]{}
 				return s.Config().(*Config)
 			},
 			expectedConfig: DefaultConfig(),
 		},
 		{
 			name: "Custom configuration",
 			setupFunc: func() *Config {
-				s := New[transaction.Tx](func(config *Config) {
+				s := NewWithConfigOptions[transaction.Tx](func(config *Config) {
 					config.Enable = false
 				})
 				return s.Config().(*Config)