feat(server/v2): add config & start helper

runtime/v2/app.go

@@ -134,3 +134,7 @@ func (a *App) SetAppVersion(context.Context, uint64) error {
 func (a *App) AppVersion(context.Context) (uint64, error) {
 	return 0, nil
 }
+
+func (a *App) GetAppManager() *appmanager.AppManager[transaction.Tx] {
+	return a.AppManager
+}

server/v2/api/grpc/server.go

@@ -15,7 +15,9 @@ import (
 
 	_ "cosmossdk.io/api/amino" // Import amino.proto file for reflection
 	appmanager "cosmossdk.io/core/app"
+	"cosmossdk.io/core/transaction"
 	"cosmossdk.io/log"
+	serverv2 "cosmossdk.io/server/v2"
 	"cosmossdk.io/server/v2/api/grpc/gogoreflection"
 )
 
@@ -33,9 +35,13 @@ type GRPCService interface {
 	RegisterGRPCServer(gogogrpc.Server)
 }
 
-// New returns a correctly configured and initialized gRPC server.
+func NewGRPCServer() GRPCServer {
+	return GRPCServer{}
+}
+
+// Init returns a correctly configured and initialized gRPC server.
 // Note, the caller is responsible for starting the server.
-func New(logger log.Logger, v *viper.Viper, interfaceRegistry appmanager.InterfaceRegistry, app GRPCService) (GRPCServer, error) {
+func (g GRPCServer) Init(appI serverv2.App[transaction.Tx], v *viper.Viper, logger log.Logger) (serverv2.ServerComponent[transaction.Tx], error) {
 	cfg := DefaultConfig()
 	if v != nil {
 		if err := v.Sub(serverName).Unmarshal(&cfg); err != nil {
@@ -44,12 +50,12 @@ func New(logger log.Logger, v *viper.Viper, interfaceRegistry appmanager.Interfa
 	}
 
 	grpcSrv := grpc.NewServer(
-		grpc.ForceServerCodec(newProtoCodec(interfaceRegistry).GRPCCodec()),
+		grpc.ForceServerCodec(newProtoCodec(appI.Application.InterfaceRegistry()).GRPCCodec()),
 		grpc.MaxSendMsgSize(cfg.MaxSendMsgSize),
 		grpc.MaxRecvMsgSize(cfg.MaxRecvMsgSize),
 	)
 
-	app.RegisterGRPCServer(grpcSrv)
+	// app.RegisterGRPCServer(grpcSrv)
 
 	// Reflection allows external clients to see what services and methods
 	// the gRPC server exposes.

server/v2/cometbft/go.mod

@@ -7,6 +7,7 @@ replace (
 	cosmossdk.io/core => ../../../core
 	cosmossdk.io/core/testing => ../../../core/testing
 	cosmossdk.io/depinject => ../../../depinject
+	cosmossdk.io/log => ../../../log
 	cosmossdk.io/server/v2 => ../
 	cosmossdk.io/server/v2/appmanager => ../appmanager
 	cosmossdk.io/store => ../../../store
@@ -38,6 +39,7 @@ require (
 	github.com/grpc-ecosystem/grpc-gateway v1.16.0
 	github.com/spf13/cobra v1.8.1
 	github.com/spf13/pflag v1.0.5
+	github.com/spf13/viper v1.19.0
 	google.golang.org/genproto/googleapis/api v0.0.0-20240318140521-94a12d6c2237
 	google.golang.org/grpc v1.64.0
 	google.golang.org/protobuf v1.34.2
@@ -156,7 +158,6 @@ require (
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.11.0 // indirect
 	github.com/spf13/cast v1.6.0 // indirect
-	github.com/spf13/viper v1.19.0 // indirect
 	github.com/stretchr/testify v1.9.0 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/supranational/blst v0.3.11 // indirect

server/v2/cometbft/go.sum

@@ -8,8 +8,6 @@ cosmossdk.io/collections v0.4.0 h1:PFmwj2W8szgpD5nOd8GWH6AbYNi1f2J6akWXJ7P5t9s=
 cosmossdk.io/collections v0.4.0/go.mod h1:oa5lUING2dP+gdDquow+QjlF45eL1t4TJDypgGd+tv0=
 cosmossdk.io/errors v1.0.1 h1:bzu+Kcr0kS/1DuPBtUFdWjzLqyUuCiyHjyJB6srBV/0=
 cosmossdk.io/errors v1.0.1/go.mod h1:MeelVSZThMi4bEakzhhhE/CKqVv3nOJDA25bIqRDu/U=
-cosmossdk.io/log v1.3.1 h1:UZx8nWIkfbbNEWusZqzAx3ZGvu54TZacWib3EzUYmGI=
-cosmossdk.io/log v1.3.1/go.mod h1:2/dIomt8mKdk6vl3OWJcPk2be3pGOS8OQaLUM/3/tCM=
 cosmossdk.io/math v1.3.0 h1:RC+jryuKeytIiictDslBP9i1fhkVm6ZDmZEoNP316zE=
 cosmossdk.io/math v1.3.0/go.mod h1:vnRTxewy+M7BtXBNFybkuhSH4WfedVAAnERHgVFhp3k=
 cosmossdk.io/x/accounts/defaults/lockup v0.0.0-20240417181816-5e7aae0db1f5 h1:eb0kcGyaYHSS0do7+MIWg7UKlskSH01biRNENbm/zDA=

server/v2/cometbft/server.go

@@ -5,6 +5,7 @@ import (
 	"crypto/sha256"
 	"encoding/json"
 	"fmt"
+	"path/filepath"
 
 	abciserver "github.com/cometbft/cometbft/abci/server"
 	cmtcmd "github.com/cometbft/cometbft/cmd/cometbft/commands"
@@ -15,7 +16,9 @@ import (
 	"github.com/cometbft/cometbft/proxy"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
 
+	corectx "cosmossdk.io/core/context"
 	"cosmossdk.io/core/log"
 	"cosmossdk.io/core/transaction"
 	serverv2 "cosmossdk.io/server/v2"
@@ -42,7 +45,7 @@ const (
 	FlagTrace         = "trace"
 )
 
-var _ serverv2.ServerModule = (*CometBFTServer[transaction.Tx])(nil)
+var _ serverv2.ServerComponent[transaction.Tx] = (*CometBFTServer[transaction.Tx])(nil)
 
 type CometBFTServer[T transaction.Tx] struct {
 	Node   *node.Node
@@ -61,20 +64,26 @@ type App[T transaction.Tx] interface {
 	GetStore() types.Store
 }
 
-func NewCometBFTServer[T transaction.Tx](
-	app *appmanager.AppManager[T],
-	store types.Store,
-	logger log.Logger,
-	cfg Config,
-	txCodec transaction.Codec[T],
-) *CometBFTServer[T] {
+func New[T transaction.Tx](txCodec transaction.Codec[T]) *CometBFTServer[T] {
+	consensus := &Consensus[T]{txCodec: txCodec}
+	return &CometBFTServer[T]{
+		App: consensus,
+	}
+}
+
+func (s *CometBFTServer[T]) Init(appI serverv2.App[T], v *viper.Viper, logger log.Logger) (serverv2.ServerComponent[T], error) {
+	app := appI.Application
+	store := appI.Store.(types.Store)
+
+	cfg := Config{CmtConfig: serverv2.GetConfigFromViper(v), ConsensusAuthority: app.GetConsensusAuthority()}
 	logger = logger.With("module", "cometbft-server")
 
 	// create noop mempool
 	mempool := mempool.NoOpMempool[T]{}
 
 	// create consensus
-	consensus := NewConsensus[T](app, mempool, store, cfg, txCodec, logger)
+	// txCodec should be in server from New()
+	consensus := NewConsensus[T](app.GetAppManager(), mempool, store, cfg, s.App.txCodec, logger)
 
 	consensus.SetPrepareProposalHandler(handlers.NoOpPrepareProposal[T]())
 	consensus.SetProcessProposalHandler(handlers.NoOpProcessProposal[T]())
@@ -93,18 +102,25 @@ func NewCometBFTServer[T transaction.Tx](
 	sm := snapshots.NewManager(snapshotStore, snapshots.SnapshotOptions{}, sc, ss, nil, logger) // TODO: set options somehow
 	consensus.SetSnapshotManager(sm)
 
+	s.config = cfg
+	s.App = consensus
+	s.logger = logger
+
 	return &CometBFTServer[T]{
 		logger: logger,
 		App:    consensus,
 		config: cfg,
-	}
+	}, nil
 }
 
 func (s *CometBFTServer[T]) Name() string {
 	return "cometbft"
 }
 
 func (s *CometBFTServer[T]) Start(ctx context.Context) error {
+	viper := ctx.Value(corectx.ViperContextKey{}).(*viper.Viper)
+	cometConfig := serverv2.GetConfigFromViper(viper)
+
 	wrappedLogger := cometlog.CometLoggerWrapper{Logger: s.logger}
 	if s.config.Standalone {
 		svr, err := abciserver.NewServer(s.config.Addr, s.config.Transport, s.App)
@@ -117,20 +133,20 @@ func (s *CometBFTServer[T]) Start(ctx context.Context) error {
 		return svr.Start()
 	}
 
-	nodeKey, err := p2p.LoadOrGenNodeKey(s.config.CmtConfig.NodeKeyFile())
+	nodeKey, err := p2p.LoadOrGenNodeKey(cometConfig.NodeKeyFile())
 	if err != nil {
 		return err
 	}
 
 	s.Node, err = node.NewNode(
 		ctx,
-		s.config.CmtConfig,
-		pvm.LoadOrGenFilePV(s.config.CmtConfig.PrivValidatorKeyFile(), s.config.CmtConfig.PrivValidatorStateFile()),
+		cometConfig,
+		pvm.LoadOrGenFilePV(cometConfig.PrivValidatorKeyFile(), cometConfig.PrivValidatorStateFile()),
 		nodeKey,
 		proxy.NewLocalClientCreator(s.App),
-		getGenDocProvider(s.config.CmtConfig),
+		getGenDocProvider(cometConfig),
 		cmtcfg.DefaultDBProvider,
-		node.DefaultMetricsProvider(s.config.CmtConfig.Instrumentation),
+		node.DefaultMetricsProvider(cometConfig.Instrumentation),
 		wrappedLogger,
 	)
 	if err != nil {
@@ -223,3 +239,9 @@ func (s *CometBFTServer[T]) CLICommands() serverv2.CLIConfig {
 		},
 	}
 }
+
+func (s *CometBFTServer[T]) WriteDefaultConfigAt(configPath string) error {
+	cometConfig := cmtcfg.DefaultConfig()
+	cmtcfg.WriteConfigFile(filepath.Join(configPath, "config.toml"), cometConfig)
+	return nil
+}

server/v2/commands.go

@@ -11,30 +11,48 @@
 
 	"github.com/spf13/cobra"
 
+	"cosmossdk.io/core/transaction"
 	"cosmossdk.io/log"
+	"github.com/spf13/viper"
 )
 
-func Commands(logger log.Logger, homePath string, modules ...ServerModule) (CLIConfig, error) {
-	if len(modules) == 0 {
-		// TODO figure if we should define default modules
-		// and if so it should be done here to avoid unnecessary dependencies
-		return CLIConfig{}, errors.New("no modules provided")
-	}
+const flagHome = "home"
 
-	v, err := ReadConfig(filepath.Join(homePath, "config"))
-	if err != nil {
-		return CLIConfig{}, fmt.Errorf("failed to read config: %w", err)
+type App[T transaction.Tx] struct {
+	Application Application[T]
+	Store       any
+}
+
+type AppCreator[T transaction.Tx] func(*viper.Viper, log.Logger) App[T]
+
+func Commands(rootCmd *cobra.Command, newApp AppCreator[transaction.Tx], logger log.Logger, components ...ServerComponent[transaction.Tx]) (CLIConfig, error) {
+	if len(components) == 0 {
+		// TODO figure if we should define default components
+		// and if so it should be done here to avoid uncessary dependencies
+		return CLIConfig{}, errors.New("no components provided")
 	}
 
-	server := NewServer(logger, modules...)
+	server := NewServer(logger, components...)
+	flags := server.StartFlags()
+
 	startCmd := &cobra.Command{
 		Use:   "start",
 		Short: "Run the application",
 		RunE: func(cmd *cobra.Command, args []string) error {
-			if err := v.BindPFlags(cmd.Flags()); err != nil { // the server modules are already instantiated here, so binding the flags is useless.
+			v := GetViperFromCmd(cmd)
+			l := GetLoggerFromCmd(cmd)
+
+			for _, startFlags := range flags {
+				v.BindPFlags(startFlags)
+			}
+
+			if err := v.BindPFlags(cmd.Flags()); err != nil {
 				return err
 			}
 
+			app := newApp(v, l)
+			server.Init(app, v, l)
+
 			srvConfig := Config{StartBlock: true}
 			ctx := cmd.Context()
 			ctx = context.WithValue(ctx, ServerContextKey, srvConfig)
@@ -65,12 +83,55 @@
 	return cmds, nil
 }
 
-func AddCommands(rootCmd *cobra.Command, logger log.Logger, homePath string, modules ...ServerModule) error {
-	cmds, err := Commands(logger, homePath, modules...)
+func AddCommands(rootCmd *cobra.Command, newApp AppCreator[transaction.Tx], logger log.Logger, components ...ServerComponent[transaction.Tx]) error {
+	cmds, err := Commands(rootCmd, newApp, logger, components...)
 	if err != nil {
 		return err
 	}
 
+	server := NewServer(logger, components...)
+	originalPersistentPreRunE := rootCmd.PersistentPreRunE
+	rootCmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
+		home, err := cmd.Flags().GetString(flagHome)
+		if err != nil {
+			return err
+		}
+
+		err = configHandle(server, home, cmd)
+		if err != nil {
+			return err
+		}
+
+		if rootCmd.PersistentPreRun != nil {
+			rootCmd.PersistentPreRun(cmd, args)
+			return nil
+		}
+
+		return originalPersistentPreRunE(cmd, args)
+	}
+
 	rootCmd.AddCommand(cmds.Commands...)
 	return nil
 }
+
+func configHandle(s *Server, home string, cmd *cobra.Command) error {
+	if _, err := os.Stat(filepath.Join(home, "config")); os.IsNotExist(err) {
+		err = s.WriteConfig(filepath.Join(home, "config"))
+		if err != nil {
+			return err
+		}
+	}
+
+	viper, err := ReadConfig(filepath.Join(home, "config"))
+	if err != nil {
+		return err
+	}
+	viper.Set(flagHome, home)
+
+	log, err := NewLogger(viper, cmd.OutOrStdout())
+	if err != nil {
+		return err
+	}
+
+	return SetCmdServerContext(cmd, viper, log)
+}