feat: create post action runapp step and emit app logs to ~/.minitia/app.log (#161)

* create post action runapp step and emit app logs to ~/.minitia/app.log

* use type

* nil safety

Author: beer-1

contrib/launchtools/cmd.go

@@ -73,6 +73,7 @@ $ launchtools launch --artifacts-dir ./ --with-config ./config.json
 				defaultGenesisGetter(config.L2Config.Denom),
 				artifactsDir,
 			)
+			defer launcher.Close()
 
 			stepFns := make([]LauncherStepFunc, len(steps))
 

contrib/launchtools/steps/ibc.go

@@ -71,7 +71,6 @@ func establishIBCChannels(
 
 		relayer := NewRelayer(ctx.Context(), relayerPath, ctx.Logger())
 		ctx.SetRelayer(relayer)
-
 		return runLifecycle(relayer)
 	}
 }

contrib/launchtools/steps/runapp.go

@@ -4,81 +4,95 @@ import (
 	"context"
 	"time"
 
+	"github.com/pkg/errors"
+	"golang.org/x/sync/errgroup"
+
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/server"
+
 	"github.com/initia-labs/OPinit/contrib/launchtools"
-	"github.com/pkg/errors"
-	"golang.org/x/sync/errgroup"
 )
 
 var _ launchtools.LauncherStepFuncFactory[*launchtools.Config] = RunApp
 
 // RunApp runs the in-process application. This routine temporarily allows creation of empty blocks,
 // in order to expedite IBC channel establishment. It waits until the app generates at least 1 block after the genesis.
-func RunApp(_ *launchtools.Config) launchtools.LauncherStepFunc {
-	return func(ctx launchtools.Launcher) error {
-		// temporarily allow creation of empty blocks
-		// this should help creation of ibc channels.
-		// NOTE: This part is ephemeral only in the context of the launcher.
-		ctx.ServerContext().Config.Consensus.CreateEmptyBlocks = true
-		ctx.ServerContext().Config.Consensus.CreateEmptyBlocksInterval = CreateEmptyBlocksInterval
-
-		// create a channel to synchronize on app creation
-		var syncDone = make(chan interface{})
-
-		// create cobra command context
-		startCmd := server.StartCmdWithOptions(
-			ctx.AppCreator(),
-			ctx.ClientContext().HomeDir,
-
-			// set up a post setup function to set the app in the context
-			server.StartCmdOptions{
-				PostSetup: func(svrCtx *server.Context, clientCtx client.Context, _ context.Context, g *errgroup.Group) (err error) {
-					// set the error group to gracefully shutdown the launch cmd
-					ctx.SetErrorGroup(g)
-
-					// wait until latest version goes to 2
-					g.Go(func() error {
-						for {
-							ctx.Logger().Info("waiting for app to be created")
-
-							if ctx.App().CommitMultiStore().LatestVersion() > 1 {
-								// Signal that the app is created
-								syncDone <- struct{}{}
-								break
+func RunApp(cfg *launchtools.Config) launchtools.LauncherStepFunc {
+	return RunAppWithPostAction(nil)(cfg)
+}
+
+// RunAppWithPostAction runs the in-process application with a post action.
+func RunAppWithPostAction(postAction launchtools.PostAction) func(cfg *launchtools.Config) launchtools.LauncherStepFunc {
+	return func(cfg *launchtools.Config) launchtools.LauncherStepFunc {
+		return func(ctx launchtools.Launcher) error {
+			// temporarily allow creation of empty blocks
+			// this should help creation of ibc channels.
+			// NOTE: This part is ephemeral only in the context of the launcher.
+			ctx.ServerContext().Config.Consensus.CreateEmptyBlocks = true
+			ctx.ServerContext().Config.Consensus.CreateEmptyBlocksInterval = CreateEmptyBlocksInterval
+
+			// create a channel to synchronize on app creation
+			var syncDone = make(chan interface{})
+
+			// create cobra command context
+			startCmd := server.StartCmdWithOptions(
+				ctx.AppCreator(),
+				ctx.ClientContext().HomeDir,
+
+				// set up a post setup function to set the app in the context
+				server.StartCmdOptions{
+					PostSetup: func(svrCtx *server.Context, clientCtx client.Context, _ctx context.Context, g *errgroup.Group) (err error) {
+						// set the error group to gracefully shutdown the launch cmd
+						ctx.SetErrorGroup(g)
+
+						// wait until latest version goes to 2
+						g.Go(func() error {
+							for {
+								ctx.Logger().Info("waiting for app to be created")
+
+								if ctx.App().CommitMultiStore().LatestVersion() > 1 {
+									// Signal that the app is created
+									syncDone <- struct{}{}
+									break
+								}
+
+								time.Sleep(1 * time.Second)
 							}
 
-							time.Sleep(1 * time.Second)
+							return nil
+						})
+
+						// if post action is set, run it
+						if postAction != nil {
+							return postAction(ctx.App(), svrCtx, clientCtx, _ctx, g)
 						}
 
 						return nil
-					})
-
-					return nil
+					},
 				},
-			},
-		)
+			)
 
-		// set relevant context; this part is necessary to correctly set up the start command and their start-up flags
-		startCmd.SetContext(ctx.Context())
+			// set relevant context; this part is necessary to correctly set up the start command and their start-up flags
+			startCmd.SetContext(ctx.Context())
 
-		// Run PreRunE from startCmd. This step is necessary to correctly set up start-up flags,
-		// as it is done usually with cometbft start command.
-		if err := startCmd.PreRunE(startCmd, nil); err != nil {
-			return errors.Wrapf(err, "failed to prerun command")
-		}
-
-		// Run RunE command - this part fires up the actual chain
-		// Note that the command is run in a separate goroutine, as it is blocking.
-		// App should be later cleaned up in another launcher step
-		go func() {
-			if err := startCmd.RunE(startCmd, nil); err != nil {
-				panic(errors.Wrapf(err, "failed to run command"))
+			// Run PreRunE from startCmd. This step is necessary to correctly set up start-up flags,
+			// as it is done usually with cometbft start command.
+			if err := startCmd.PreRunE(startCmd, nil); err != nil {
+				return errors.Wrapf(err, "failed to prerun command")
 			}
-		}()
 
-		<-syncDone
+			// Run RunE command - this part fires up the actual chain
+			// Note that the command is run in a separate goroutine, as it is blocking.
+			// App should be later cleaned up in another launcher step
+			go func() {
+				if err := startCmd.RunE(startCmd, nil); err != nil {
+					panic(errors.Wrapf(err, "failed to run command"))
+				}
+			}()
+
+			<-syncDone
 
-		return nil
+			return nil
+		}
 	}
 }

contrib/launchtools/types.go

@@ -43,6 +43,9 @@ type ExpectedApp interface {
 	GetIBCKeeper() *ibckeeper.Keeper
 }
 
+// PostAction is a function that is called after the app is created.
+type PostAction func(app ExpectedApp, svrCtx *server.Context, clientCtx client.Context, ctx context.Context, g *errgroup.Group) error
+
 type AppCreator interface {
 	AppCreator() servertypes.AppCreator
 	App() servertypes.Application
@@ -112,7 +115,8 @@ type Launcher interface {
 var _ Launcher = &LauncherContext{}
 
 type LauncherContext struct {
-	mtx *sync.Mutex
+	mtx        *sync.Mutex
+	appLogFile *os.File
 
 	log            log.Logger
 	defaultGenesis map[string]json.RawMessage
@@ -154,8 +158,14 @@ func NewLauncher(
 	// create a new client context with the keyring
 	nextClientCtx := clientCtx.WithKeyring(kr)
 
-	// mute log output
-	serverCtx.Logger = log.NewNopLogger()
+	// record app logs to file
+	appLogFile, err := os.Create(path.Join(nextClientCtx.HomeDir, "app.log"))
+	if err != nil {
+		panic("failed to create log file")
+	}
+
+	serverCtx.Logger.Info("logging app logs to file", "file", appLogFile.Name())
+	serverCtx.Logger = log.NewLogger(appLogFile, log.OutputJSONOption())
 
 	// make sure to register both ophost and opchild proto
 	// otherwise it fails on creating op bridge on L1
@@ -169,8 +179,9 @@ func NewLauncher(
 	}
 
 	return &LauncherContext{
-		log:            log.NewLogger(os.Stderr),
 		mtx:            new(sync.Mutex),
+		appLogFile:     appLogFile,
+		log:            log.NewLogger(os.Stderr),
 		clientCtx:      &nextClientCtx,
 		serverCtx:      serverCtx,
 		appCreator:     appCreator,
@@ -290,3 +301,13 @@ func (l *LauncherContext) SetErrorGroup(g *errgroup.Group) {
 func (l *LauncherContext) GetErrorGroup() *errgroup.Group {
 	return l.errorgroup
 }
+
+func (l *LauncherContext) Close() error {
+	if l.appLogFile != nil {
+		if err := l.appLogFile.Close(); err != nil {
+			return errors.Wrap(err, "failed to close app log file")
+		}
+	}
+
+	return nil
+}