Refactor/single process multiple services

cmd/cartesi-rollups-advancer/root/root.go

@@ -9,6 +9,8 @@ import (
 	"github.com/cartesi/rollups-node/internal/advancer"
 	"github.com/cartesi/rollups-node/internal/cli"
 	"github.com/cartesi/rollups-node/internal/config"
+	"github.com/cartesi/rollups-node/internal/inspect"
+	"github.com/cartesi/rollups-node/internal/manager"
 	"github.com/cartesi/rollups-node/internal/repository/factory"
 	"github.com/cartesi/rollups-node/internal/version"
 	"github.com/cartesi/rollups-node/pkg/service"
@@ -79,29 +81,57 @@ func run(cmd *cobra.Command, args []string) {
 	ctx, cancel := context.WithTimeout(context.Background(), cfg.MaxStartupTime)
 	defer cancel()
 
-	createInfo := advancer.CreateInfo{
-		CreateInfo: service.CreateInfo{
-			Name:                 config.ServiceAdvancer,
-			LogLevel:             config.ResolveServiceLogLevel(config.ServiceAdvancer, cfg.LogLevel),
-			LogColor:             cfg.LogColor,
-			EnableSignalHandling: true,
-			TelemetryCreate:      true,
-			TelemetryAddress:     cfg.AdvancerTelemetryAddress,
-			PollInterval:         cfg.AdvancerPollingInterval,
-		},
-		Config: *cfg,
-	}
-	logger := service.NewServiceLogger(&createInfo.CreateInfo)
-	createInfo.CreateInfo.Logger = logger
+	// Create shared components
 
-	var err error
-	createInfo.Repository, err = factory.NewRepositoryFromConnectionString(ctx, cfg.DatabaseConnection.Raw())
-	cli.CheckErr(logger, err)
-	defer createInfo.Repository.Close()
+	name := config.ServiceAdvancer
+	logger := service.NewLogger(name, cfg.LogLevel, cfg.LogColor)
 
-	advancerService, err := advancer.Create(ctx, &createInfo)
+	repo, err := factory.NewRepositoryFromConnectionString(ctx, cfg.DatabaseConnection.Raw())
 	cli.CheckErr(logger, err)
-	advancerService.LogConfig(createInfo.Config)
+	defer repo.Close()
 
-	cli.CheckErr(logger, advancerService.Serve())
+	machineManager := manager.NewMachineManager(
+		repo,
+		logger,
+		cfg.FeatureMachineHashCheckEnabled,
+		cfg.AdvancerInputBatchSize,
+	)
+	defer machineManager.Close()
+
+	// Create factories of services
+
+	factories := []service.FactoryFunction{
+		func(ctx context.Context, sup *service.Supervisor) (service.SupervisedService, error) {
+			return advancer.Create(ctx, &advancer.CreateInfo{
+				Config:     *cfg,
+				Repository: repo,
+				Machines:   machineManager,
+				Supervisor: sup,
+				Logger:     sup.Logger,
+			})
+		},
+	}
+
+	if cfg.FeatureInspectEnabled {
+		factories = append(factories,
+			func(ctx context.Context, sup *service.Supervisor) (service.SupervisedService, error) {
+				return inspect.Create(ctx, &inspect.CreateInfo{
+					Config:     *cfg,
+					Repository: repo,
+					Machines:   machineManager,
+				})
+			},
+		)
+	}
+
+	supCfg := &service.SupervisorConfigs{
+		BaseConfigs:          service.BaseConfigs{Name: name, Logger: logger},
+		EnableSignalHandling: true,
+		TelemetryCreate:      true,
+		TelemetryAddress:     cfg.AdvancerTelemetryAddress,
+		Factories:            factories,
+	}
+	sup := service.NewSupervisor(supCfg)
+	defer sup.Close()
+	cli.CheckErr(logger, sup.Serve(ctx))
 }

cmd/cartesi-rollups-claimer/root/root.go

@@ -11,7 +11,6 @@ import (
 	"github.com/cartesi/rollups-node/internal/config"
 	"github.com/cartesi/rollups-node/internal/repository/factory"
 	"github.com/cartesi/rollups-node/internal/version"
-	"github.com/cartesi/rollups-node/pkg/ethutil"
 	"github.com/cartesi/rollups-node/pkg/service"
 
 	"github.com/spf13/cobra"
@@ -80,41 +79,29 @@ func run(cmd *cobra.Command, args []string) {
 	ctx, cancel := context.WithTimeout(context.Background(), cfg.MaxStartupTime)
 	defer cancel()
 
-	createInfo := claimer.CreateInfo{
-		CreateInfo: service.CreateInfo{
-			Name:                 config.ServiceClaimer,
-			LogLevel:             config.ResolveServiceLogLevel(config.ServiceClaimer, cfg.LogLevel),
-			LogColor:             cfg.LogColor,
-			EnableSignalHandling: true,
-			TelemetryCreate:      true,
-			TelemetryAddress:     cfg.ClaimerTelemetryAddress,
-			PollInterval:         cfg.ClaimerPollingInterval,
-		},
-		Config: *cfg,
-	}
-	logger := service.NewServiceLogger(&createInfo.CreateInfo)
-	createInfo.CreateInfo.Logger = logger
-
-	authOpt, err := config.HTTPAuthorizationOption()
-	cli.CheckErr(logger, err)
-	createInfo.EthConn, err = ethutil.NewEthClient(
-		ctx, cfg.BlockchainHttpEndpoint.Raw(), logger,
-		ethutil.RetryConfig{
-			MaxRetries:     cfg.BlockchainHttpMaxRetries,
-			RetryMinWait:   cfg.BlockchainHttpRetryMinWait,
-			RetryMaxWait:   cfg.BlockchainHttpRetryMaxWait,
-			RequestTimeout: cfg.BlockchainHttpRequestTimeout,
-		}, authOpt)
-	cli.CheckErr(logger, err)
+	name := config.ServiceClaimer
+	logger := service.NewLogger(name, cfg.LogLevel, cfg.LogColor)
 
-	createInfo.Repository, err = factory.NewRepositoryFromConnectionString(ctx, cfg.DatabaseConnection.Raw())
-	cli.CheckErr(logger, err)
-	defer createInfo.Repository.Close()
-
-	claimerService, err := claimer.Create(ctx, &createInfo)
-	cli.CheckErr(logger, err)
-	claimerService.LogConfig(createInfo.Config)
-
-	err = claimerService.Serve()
+	repo, err := factory.NewRepositoryFromConnectionString(ctx, cfg.DatabaseConnection.Raw())
 	cli.CheckErr(logger, err)
+	defer repo.Close()
+
+	supCfg := &service.SupervisorConfigs{
+		BaseConfigs:          service.BaseConfigs{Name: name, Logger: logger},
+		EnableSignalHandling: true,
+		TelemetryCreate:      true,
+		TelemetryAddress:     cfg.ClaimerTelemetryAddress,
+		Factories: []service.FactoryFunction{
+			func(ctx context.Context, sup *service.Supervisor) (service.SupervisedService, error) {
+				return claimer.Create(ctx, &claimer.CreateInfo{
+					Config:     *cfg,
+					Logger:     sup.Logger,
+					Repository: repo,
+				})
+			},
+		},
+	}
+	sup := service.NewSupervisor(supCfg)
+	defer sup.Close()
+	cli.CheckErr(logger, sup.Serve(ctx))
 }

cmd/cartesi-rollups-evm-reader/root/root.go

@@ -11,7 +11,6 @@ import (
 	"github.com/cartesi/rollups-node/internal/evmreader"
 	"github.com/cartesi/rollups-node/internal/repository/factory"
 	"github.com/cartesi/rollups-node/internal/version"
-	"github.com/cartesi/rollups-node/pkg/ethutil"
 	"github.com/cartesi/rollups-node/pkg/service"
 
 	"github.com/spf13/cobra"
@@ -80,42 +79,29 @@ func run(cmd *cobra.Command, args []string) {
 	ctx, cancel := context.WithTimeout(context.Background(), cfg.MaxStartupTime)
 	defer cancel()
 
-	createInfo := evmreader.CreateInfo{
-		CreateInfo: service.CreateInfo{
-			Name:                 config.ServiceEvmReader,
-			LogLevel:             config.ResolveServiceLogLevel(config.ServiceEvmReader, cfg.LogLevel),
-			LogColor:             cfg.LogColor,
-			EnableSignalHandling: true,
-			TelemetryCreate:      true,
-			TelemetryAddress:     cfg.EvmReaderTelemetryAddress,
-			PollInterval:         cfg.EvmReaderPollingInterval,
-		},
-		Config: *cfg,
-	}
-	logger := service.NewServiceLogger(&createInfo.CreateInfo)
-	createInfo.CreateInfo.Logger = logger
-
-	var err error
-	authOpt, err := config.HTTPAuthorizationOption()
-	cli.CheckErr(logger, err)
-	createInfo.EthClient, err = ethutil.NewEthClient(
-		ctx, cfg.BlockchainHttpEndpoint.Raw(), logger,
-		ethutil.RetryConfig{
-			MaxRetries:     cfg.BlockchainHttpMaxRetries,
-			RetryMinWait:   cfg.BlockchainHttpRetryMinWait,
-			RetryMaxWait:   cfg.BlockchainHttpRetryMaxWait,
-			RequestTimeout: cfg.BlockchainHttpRequestTimeout,
-		}, authOpt)
-	cli.CheckErr(logger, err)
+	name := config.ServiceEvmReader
+	logger := service.NewLogger(name, cfg.LogLevel, cfg.LogColor)
 
 	repo, err := factory.NewRepositoryFromConnectionString(ctx, cfg.DatabaseConnection.Raw())
 	cli.CheckErr(logger, err)
 	defer repo.Close()
-	createInfo.Repository = repo
 
-	readerService, err := evmreader.Create(ctx, &createInfo)
-	cli.CheckErr(logger, err)
-	readerService.LogConfig(createInfo.Config)
-
-	cli.CheckErr(logger, readerService.Serve())
+	supCfg := &service.SupervisorConfigs{
+		BaseConfigs:          service.BaseConfigs{Name: name, Logger: logger},
+		EnableSignalHandling: true,
+		TelemetryCreate:      true,
+		TelemetryAddress:     cfg.EvmReaderTelemetryAddress,
+		Factories: []service.FactoryFunction{
+			func(ctx context.Context, sup *service.Supervisor) (service.SupervisedService, error) {
+				return evmreader.Create(ctx, &evmreader.CreateInfo{
+					Config:     *cfg,
+					Logger:     sup.Logger,
+					Repository: repo,
+				})
+			},
+		},
+	}
+	sup := service.NewSupervisor(supCfg)
+	defer sup.Close()
+	cli.CheckErr(logger, sup.Serve(ctx))
 }

cmd/cartesi-rollups-jsonrpc-api/root/root.go

@@ -67,28 +67,29 @@ func run(cmd *cobra.Command, args []string) {
 	ctx, cancel := context.WithTimeout(context.Background(), cfg.MaxStartupTime)
 	defer cancel()
 
-	createInfo := jsonrpc.CreateInfo{
-		CreateInfo: service.CreateInfo{
-			Name:                 config.ServiceJsonrpc,
-			LogLevel:             config.ResolveServiceLogLevel(config.ServiceJsonrpc, cfg.LogLevel),
-			LogColor:             cfg.LogColor,
-			EnableSignalHandling: true,
-			TelemetryCreate:      true,
-			TelemetryAddress:     cfg.JsonrpcTelemetryAddress,
-		},
-		Config: *cfg,
-	}
-	logger := service.NewServiceLogger(&createInfo.CreateInfo)
-	createInfo.CreateInfo.Logger = logger
-
-	var err error
-	createInfo.Repository, err = factory.NewRepositoryFromConnectionString(ctx, cfg.DatabaseConnection.Raw())
-	cli.CheckErr(logger, err)
-	defer createInfo.Repository.Close()
+	name := config.ServiceJsonrpc
+	logger := service.NewLogger(name, cfg.LogLevel, cfg.LogColor)
 
-	jsonrpcService, err := jsonrpc.Create(ctx, &createInfo)
+	repo, err := factory.NewRepositoryFromConnectionString(ctx, cfg.DatabaseConnection.Raw())
 	cli.CheckErr(logger, err)
-	jsonrpcService.LogConfig(createInfo.Config)
+	defer repo.Close()
 
-	cli.CheckErr(logger, jsonrpcService.Serve())
+	supCfg := &service.SupervisorConfigs{
+		BaseConfigs:          service.BaseConfigs{Name: name, Logger: logger},
+		EnableSignalHandling: true,
+		TelemetryCreate:      true,
+		TelemetryAddress:     cfg.JsonrpcTelemetryAddress,
+		Factories: []service.FactoryFunction{
+			func(ctx context.Context, sup *service.Supervisor) (service.SupervisedService, error) {
+				return jsonrpc.Create(ctx, &jsonrpc.CreateInfo{
+					Config:     *cfg,
+					Logger:     sup.Logger,
+					Repository: repo,
+				})
+			},
+		},
+	}
+	sup := service.NewSupervisor(supCfg)
+	defer sup.Close()
+	cli.CheckErr(logger, sup.Serve(ctx))
 }