diff --git a/build/lido-exporter b/build/lido-exporter deleted file mode 100644 index 55d24101a..000000000 Binary files a/build/lido-exporter and /dev/null differ diff --git a/build/sedg.exee b/build/sedg.exee deleted file mode 100644 index 49d897665..000000000 Binary files a/build/sedg.exee and /dev/null differ diff --git a/build/sedge.exe b/build/sedge.exe deleted file mode 100644 index b8c0f54ef..000000000 Binary files a/build/sedge.exe and /dev/null differ diff --git a/cli/cli.go b/cli/cli.go index e5de749e9..a4c3cbc53 100644 --- a/cli/cli.go +++ b/cli/cli.go @@ -23,12 +23,12 @@ import ( "strings" "time" - eth2 "github.com/protolambda/zrnt/eth2/configs" "github.com/NethermindEth/sedge/internal/pkg/clients" "github.com/NethermindEth/sedge/internal/pkg/dependencies" "github.com/NethermindEth/sedge/internal/pkg/generate" sedgeOpts "github.com/NethermindEth/sedge/internal/pkg/options" "github.com/NethermindEth/sedge/internal/ui" + eth2 "github.com/protolambda/zrnt/eth2/configs" "github.com/NethermindEth/sedge/cli/actions" "github.com/NethermindEth/sedge/configs" @@ -83,7 +83,7 @@ type CliCmdOptions struct { numberOfValidators int64 existingValidators int64 installDependencies bool - enableMonitoring bool + enableMonitoring bool } func CliCmd(p ui.Prompter, actions actions.SedgeActions, depsMgr dependencies.DependenciesManager, monitoringMgr MonitoringManager) *cobra.Command { @@ -399,8 +399,8 @@ func postGenerate(p ui.Prompter, o *CliCmdOptions, a actions.SedgeActions, depsM } if o.enableMonitoring { if err := InitMonitoring(true, true, monitoringMgr, nil); err != nil { - return err - } + return err + } } if o.withValidator { log.Info(configs.HappyStakingRun) @@ -836,8 +836,8 @@ func confirmEnableMEVBoost(p ui.Prompter, o *CliCmdOptions) (err error) { } func confirmEnableMonitoring(p ui.Prompter, o *CliCmdOptions) (err error) { - o.enableMonitoring, err = p.Confirm("Do you want to enable the monitoring stack?", false) - return + o.enableMonitoring, err = p.Confirm("Do you want to enable the monitoring stack?", false) + return } func inputCustomNetworkConfig(p ui.Prompter, o *CliCmdOptions) (err error) { diff --git a/cli/monitoring.go b/cli/monitoring.go index 8ea643def..2b704475f 100644 --- a/cli/monitoring.go +++ b/cli/monitoring.go @@ -29,17 +29,16 @@ import ( "github.com/NethermindEth/sedge/configs" "github.com/NethermindEth/sedge/internal/common" "github.com/NethermindEth/sedge/internal/monitoring" + lidoExporter "github.com/NethermindEth/sedge/internal/monitoring/services/lido_exporter" + sedgeOpts "github.com/NethermindEth/sedge/internal/pkg/options" "github.com/NethermindEth/sedge/internal/ui" "github.com/NethermindEth/sedge/internal/utils" - sedgeOpts "github.com/NethermindEth/sedge/internal/pkg/options" - lidoExporter "github.com/NethermindEth/sedge/internal/monitoring/services/lido_exporter" ) -var ( - lido bool -) +var lido bool + const ( - initMonitoring = "init" + initMonitoring = "init" cleanMonitoring = "clean" ) @@ -78,11 +77,11 @@ func CleanSubCmd(mgr MonitoringManager) *cobra.Command { } func LidoSubCmd(mgr MonitoringManager, additionalServices []monitoring.ServiceAPI) *cobra.Command { - lido:= &lidoExporter.LidoExporterParams{} - cmd:= &cobra.Command{ + lido := &lidoExporter.LidoExporterParams{} + cmd := &cobra.Command{ Use: "lido", Short: "Configure Lido CSM Node monitoring", - Args: cobra.NoArgs, + Args: cobra.NoArgs, PreRunE: func(cmd *cobra.Command, args []string) error { if lido.NodeOperatorID == "" && lido.RewardAddress == "" { return errors.New("Node Operator ID or Reward Address is required") @@ -97,23 +96,23 @@ func LidoSubCmd(mgr MonitoringManager, additionalServices []monitoring.ServiceAP return InitMonitoring(true, true, mgr, additionalServices) }, } - cmd.Flags().StringVar(&lido.NodeOperatorID,"node-operator-id", "", "Node Operator ID") - cmd.Flags().StringVar(&lido.RewardAddress,"reward-address", "", "Reward address of Node Operator. It is used to calculate Node Operator ID if not set") - cmd.Flags().StringVar(&lido.Network,"network", "holesky", "Network name") - cmd.Flags().StringSliceVar(&lido.RPCEndpoints,"rpc-endpoints", nil, "List of Ethereum HTTP RPC endpoints") - cmd.Flags().StringSliceVar(&lido.WSEndpoints,"ws-endpoints", nil, "List of Ethereum WebSocket RPC endpoints") - cmd.Flags().Uint16Var(&lido.Port,"port", 8080, "Port where the metrics will be exported.") - cmd.Flags().DurationVar(&lido.ScrapeTime,"scrape-time", 30*time.Second, "Time interval for scraping metrics. Values should be in the format of 10s, 1m, 1h, etc.") + cmd.Flags().StringVar(&lido.NodeOperatorID, "node-operator-id", "", "Node Operator ID") + cmd.Flags().StringVar(&lido.RewardAddress, "reward-address", "", "Reward address of Node Operator. It is used to calculate Node Operator ID if not set") + cmd.Flags().StringVar(&lido.Network, "network", "holesky", "Network name") + cmd.Flags().StringSliceVar(&lido.RPCEndpoints, "rpc-endpoints", nil, "List of Ethereum HTTP RPC endpoints") + cmd.Flags().StringSliceVar(&lido.WSEndpoints, "ws-endpoints", nil, "List of Ethereum WebSocket RPC endpoints") + cmd.Flags().Uint16Var(&lido.Port, "port", 8080, "Port where the metrics will be exported.") + cmd.Flags().DurationVar(&lido.ScrapeTime, "scrape-time", 30*time.Second, "Time interval for scraping metrics. Values should be in the format of 10s, 1m, 1h, etc.") cmd.Flags().StringVar(&logLevel, "log-level", "info", "Set Log Level, e.g panic, fatal, error, warn, warning, info, debug, trace") return cmd } func DefaultSubCmd(mgr MonitoringManager, additionalServices []monitoring.ServiceAPI) *cobra.Command { - cmd:= &cobra.Command{ + cmd := &cobra.Command{ Use: "default", Short: "Default monitoring configuration", - Args: cobra.NoArgs, + Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, args []string) error { return InitMonitoring(true, true, mgr, nil) }, @@ -121,7 +120,6 @@ func DefaultSubCmd(mgr MonitoringManager, additionalServices []monitoring.Servic return cmd } - // Init initializes the Monitoring Stack. If install is true, it will install the Monitoring Stack if it is not installed. // If run is true, it will run the Monitoring Stack if it is not running. func InitMonitoring(install, run bool, monitoringMgr MonitoringManager, additionalServices []monitoring.ServiceAPI) error { @@ -146,12 +144,12 @@ func InitMonitoring(install, run bool, monitoringMgr MonitoringManager, addition } // Add additional services to the monitoring manager - for _, service := range additionalServices { - if err := monitoringMgr.AddService(service); err != nil { - return fmt.Errorf("failed to add service %s: %w", service.Name(), err) - } - } - + for _, service := range additionalServices { + if err := monitoringMgr.AddService(service); err != nil { + return fmt.Errorf("failed to add service %s: %w", service.Name(), err) + } + } + // Check if the monitoring stack is running. status, err := monitoringMgr.Status() if err != nil { @@ -194,29 +192,29 @@ func CleanMonitoring(monitoringMgr MonitoringManager) error { func InputLidoExporterParams(p ui.Prompter) (*lidoExporter.LidoExporterParams, error) { lido := sedgeOpts.CreateSedgeOptions(sedgeOpts.LidoNode) - params := &lidoExporter.LidoExporterParams{} - var err error + params := &lidoExporter.LidoExporterParams{} + var err error - // Node Operator ID - params.NodeOperatorID, err = p.Input("Enter Node Operator ID (leave empty if using Reward Address)", "", false, nil) - if err != nil { - return params, err - } + // Node Operator ID + params.NodeOperatorID, err = p.Input("Enter Node Operator ID (leave empty if using Reward Address)", "", false, nil) + if err != nil { + return params, err + } // Reward Address - if params.NodeOperatorID == "" { - params.RewardAddress, err = p.EthAddress("Enter Reward Address of Node Operator", "", true) - if err != nil { - return params, err - } - } + if params.NodeOperatorID == "" { + params.RewardAddress, err = p.EthAddress("Enter Reward Address of Node Operator", "", true) + if err != nil { + return params, err + } + } // Network options := lido.SupportedNetworks() - index, err := p.Select("Select network", "holesky", options) - if err != nil { - return params, err - } + index, err := p.Select("Select network", "holesky", options) + if err != nil { + return params, err + } params.Network = options[index] // RPC URLs @@ -233,39 +231,39 @@ func InputLidoExporterParams(p ui.Prompter) (*lidoExporter.LidoExporterParams, e // WSs URLs defaultWSURLs, err := configs.GetPublicWSs(params.Network) wsURLs, err := p.InputList("Insert Ethereum WebSocket RPC endpoints if you don't want to use the default values listed below", defaultWSURLs, nil) - if err != nil { - return params, err - } + if err != nil { + return params, err + } params.WSEndpoints = wsURLs - + // Port - portStr, err := p.Input("Enter port for exporting metrics", "8080", false, nil) - if err != nil { - return params, err - } - port64, err := strconv.ParseUint(portStr, 10, 16) - if err != nil { - return params, fmt.Errorf("invalid port number: %v", err) - } - params.Port = uint16(port64) + portStr, err := p.Input("Enter port for exporting metrics", "8080", false, nil) + if err != nil { + return params, err + } + port64, err := strconv.ParseUint(portStr, 10, 16) + if err != nil { + return params, fmt.Errorf("invalid port number: %v", err) + } + params.Port = uint16(port64) // Scrape time - scrapeTimeStr, err := p.Input("Enter scrape time interval (e.g., 30s, 1m, 1h)", "30s", false, nil) - if err != nil { - return params, err - } - params.ScrapeTime, err = time.ParseDuration(scrapeTimeStr) - if err != nil { - return params, fmt.Errorf("invalid scrape time: %v", err) - } - - //Log level + scrapeTimeStr, err := p.Input("Enter scrape time interval (e.g., 30s, 1m, 1h)", "30s", false, nil) + if err != nil { + return params, err + } + params.ScrapeTime, err = time.ParseDuration(scrapeTimeStr) + if err != nil { + return params, fmt.Errorf("invalid scrape time: %v", err) + } + + // Log level logOptions := []string{"panic", "fatal", "error", "warn", "warning", "info", "debug", "trace"} - index, err = p.Select("Select log level", "info", logOptions) - if err != nil { - return params, err - } + index, err = p.Select("Select log level", "info", logOptions) + if err != nil { + return params, err + } params.LogLevel = logOptions[index] - return params, nil -} \ No newline at end of file + return params, nil +} diff --git a/cli/monitoringManager.go b/cli/monitoringManager.go index cb8928af9..a364b4dd6 100644 --- a/cli/monitoringManager.go +++ b/cli/monitoringManager.go @@ -4,8 +4,8 @@ package cli import ( "github.com/NethermindEth/sedge/internal/common" - "github.com/NethermindEth/sedge/internal/monitoring/services/types" "github.com/NethermindEth/sedge/internal/monitoring" + "github.com/NethermindEth/sedge/internal/monitoring/services/types" ) type MonitoringManager interface { diff --git a/e2e/sedge/checks.go b/e2e/sedge/checks.go index a38a17304..0c9101714 100644 --- a/e2e/sedge/checks.go +++ b/e2e/sedge/checks.go @@ -165,9 +165,10 @@ func checkGrafanaHealth(t *testing.T) { } // checkMonitoringStackContainersNotRunning checks that the monitoring stack containers are not running -func checkMonitoringStackContainersNotRunning(t *testing.T) { +func checkMonitoringStackContainersNotRunning(t *testing.T, containerNames ...string) { t.Logf("Checking monitoring stack containers are not running") - checkContainerNotExisting(t, "sedge_grafana", "sedge_prometheus", "sedge_node_exporter") + containerNames = append(containerNames, "sedge_grafana", "sedge_prometheus", "sedge_node_exporter") + checkContainerNotExisting(t, containerNames...) } // checkContainerNotExisting checks that the given containers are not existing diff --git a/e2e/sedge/monitoring_stack_test.go b/e2e/sedge/monitoring_stack_test.go index 982cf872a..45bed737e 100644 --- a/e2e/sedge/monitoring_stack_test.go +++ b/e2e/sedge/monitoring_stack_test.go @@ -62,7 +62,7 @@ func TestE2E_MonitoringStack_Init(t *testing.T) { nil, // Act func(t *testing.T, binaryPath string, dataDirPath string) { - runErr = base.RunCommand(t, binaryPath, "sedge", "monitoring", "init","default") + runErr = base.RunCommand(t, binaryPath, "sedge", "monitoring", "init", "default") }, // Assert func(t *testing.T, dataDirPath string) { @@ -90,7 +90,7 @@ func TestE2E_MonitoringStack_NotReinstalled(t *testing.T) { t, // Arrange func(t *testing.T, sedgePath string) error { - err := base.RunCommand(t, sedgePath, "sedge", "monitoring", "init","default") + err := base.RunCommand(t, sedgePath, "sedge", "monitoring", "init", "default") if err != nil { return err } @@ -141,7 +141,7 @@ func TestE2E_MonitoringStack_Clean(t *testing.T) { t, // Arrange func(t *testing.T, sedgePath string) error { - return base.RunCommand(t, sedgePath, "sedge", "monitoring", "init","default") + return base.RunCommand(t, sedgePath, "sedge", "monitoring", "init", "default") }, // Act func(t *testing.T, binaryPath string, dataDirPath string) { @@ -190,3 +190,61 @@ func TestE2E_MonitoringStack_CleanNonExistent(t *testing.T) { // Run test case e2eTest.run() } + +func TestE2E_MonitoringStack_InitLido(t *testing.T) { + // Test context + var ( + runErr error + ) + // Build test case + e2eTest := newE2ESedgeTestCase( + t, + // Arrange + nil, + // Act + func(t *testing.T, binaryPath string, dataDirPath string) { + runErr = base.RunCommand(t, binaryPath, "sedge", "monitoring", "init", "lido", "--node-operator-id", "1") + }, + // Assert + func(t *testing.T, dataDirPath string) { + assert.NoError(t, runErr) + checkMonitoringStackDir(t) + checkMonitoringStackContainers(t) + checkPrometheusTargetsUp(t, "sedge_lido_exporter:8080") + checkGrafanaHealth(t) + }, + ) + // Run test case + e2eTest.run() +} + +func TestE2E_MonitoringStack_CleanLido(t *testing.T) { + // Test context + var ( + runErr error + ) + // Build test case + e2eTest := newE2ESedgeTestCase( + t, + // Arrange + func(t *testing.T, sedgePath string) error { + return base.RunCommand(t, sedgePath, "sedge", "monitoring", "init", "default") + }, + // Act + func(t *testing.T, binaryPath string, dataDirPath string) { + runErr = base.RunCommand(t, binaryPath, "sedge", "monitoring", "clean") + }, + // Assert + func(t *testing.T, dataDirPath string) { + assert.NoError(t, runErr) + + // Check that monitoring stack directory is removed + assert.NoDirExists(t, dataDirPath) + + // Check that monitoring stack containers are removed + checkMonitoringStackContainersNotRunning(t, "sedge_lido_exporter") + }, + ) + // Run test case + e2eTest.run() +} diff --git a/go.mod b/go.mod index 347e1f23a..850c82c7b 100644 --- a/go.mod +++ b/go.mod @@ -154,12 +154,15 @@ require ( go.uber.org/atomic v1.9.0 // indirect go.uber.org/multierr v1.9.0 // indirect golang.org/x/crypto v0.25.0 // indirect + golang.org/x/mod v0.17.0 // indirect golang.org/x/net v0.27.0 // indirect golang.org/x/term v0.22.0 // indirect golang.org/x/text v0.16.0 // indirect + golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20240701130421-f6361c86f094 // indirect google.golang.org/grpc v1.65.0 // indirect google.golang.org/protobuf v1.34.2 // indirect gopkg.in/ini.v1 v1.67.0 // indirect + mvdan.cc/gofumpt v0.7.0 // indirect rsc.io/tmplfunc v0.0.3 // indirect ) diff --git a/go.sum b/go.sum index aa6c02529..f2beb679d 100644 --- a/go.sum +++ b/go.sum @@ -430,6 +430,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= +golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA= +golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -488,6 +490,8 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg= +golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -516,5 +520,7 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o= gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g= +mvdan.cc/gofumpt v0.7.0 h1:bg91ttqXmi9y2xawvkuMXyvAA/1ZGJqYAEGjXuP0JXU= +mvdan.cc/gofumpt v0.7.0/go.mod h1:txVFJy/Sc/mvaycET54pV8SW8gWxTlUuGHVEcncmNUo= rsc.io/tmplfunc v0.0.3 h1:53XFQh69AfOa8Tw0Jm7t+GV7KZhOi6jzsCzTtKbMvzU= rsc.io/tmplfunc v0.0.3/go.mod h1:AG3sTPzElb1Io3Yg4voV9AGZJuleGAwaVRxL9M49PhA= diff --git a/internal/monitoring/data/monitoring.go b/internal/monitoring/data/monitoring.go index 35270975a..a2bbf3410 100644 --- a/internal/monitoring/data/monitoring.go +++ b/internal/monitoring/data/monitoring.go @@ -72,31 +72,31 @@ func (m *MonitoringStack) unlock() error { // Setup sets up the monitoring stack with the given environment variables and // docker-compose_base.tmpl file. func (m *MonitoringStack) Setup(env map[string]string, monitoringFs fs.FS) (err error) { - err = m.lock() - if err != nil { - return err - } - defer func() { - unlockErr := m.unlock() - if err == nil { - err = unlockErr - } - }() - - // Create .env file - envFile, err := m.fs.Create(filepath.Join(m.path, ".env")) - if err != nil { - return err - } - for k, v := range env { - _, err = envFile.WriteString(fmt.Sprintf("%s=%s\n", k, v)) - if err != nil { - return fmt.Errorf("failed to write to .env file: %w", err) - } - } - defer envFile.Close() - - // Read the main Docker Compose template + err = m.lock() + if err != nil { + return err + } + defer func() { + unlockErr := m.unlock() + if err == nil { + err = unlockErr + } + }() + + // Create .env file + envFile, err := m.fs.Create(filepath.Join(m.path, ".env")) + if err != nil { + return err + } + for k, v := range env { + _, err = envFile.WriteString(fmt.Sprintf("%s=%s\n", k, v)) + if err != nil { + return fmt.Errorf("failed to write to .env file: %w", err) + } + } + defer envFile.Close() + + // Read the main Docker Compose template rawBaseTmp, err := monitoringFs.Open("services/docker-compose_base.tmpl") if err != nil { return fmt.Errorf("error opening docker-compose template: %w", err) @@ -120,7 +120,7 @@ func (m *MonitoringStack) Setup(env map[string]string, monitoringFs fs.FS) (err // Execute the base template without any additional data if err := baseTmp.Execute(&buf, nil); err != nil { - return fmt.Errorf("error executing docker-compose template: %w", err) + return fmt.Errorf("error executing docker-compose template: %w", err) } // Write the executed template content to the final Docker Compose file @@ -135,7 +135,7 @@ func (m *MonitoringStack) Setup(env map[string]string, monitoringFs fs.FS) (err return fmt.Errorf("error writing docker-compose.yml file: %w", err) } - return nil + return nil } // CreateDir creates a new directory in the monitoring stack at the given path. @@ -267,4 +267,3 @@ func (m *MonitoringStack) Cleanup(force bool) (err error) { } return m.fs.RemoveAll(m.path) } - diff --git a/internal/monitoring/data/monitoring_test.go b/internal/monitoring/data/monitoring_test.go index 0e7133fdc..37d31ce77 100644 --- a/internal/monitoring/data/monitoring_test.go +++ b/internal/monitoring/data/monitoring_test.go @@ -64,20 +64,20 @@ func TestInit(t *testing.T) { } func TestSetup(t *testing.T) { - t.Parallel() - - okLocker := func(t *testing.T) *mocks.MockLocker { - ctrl := gomock.NewController(t) - locker := mocks.NewMockLocker(ctrl) - gomock.InOrder( - locker.EXPECT().Lock().Return(nil), - locker.EXPECT().Locked().Return(true), - locker.EXPECT().Unlock().Return(nil), - ) - return locker - } - - mockTemplate := `{{/* docker-compose_base.tmpl */}} + t.Parallel() + + okLocker := func(t *testing.T) *mocks.MockLocker { + ctrl := gomock.NewController(t) + locker := mocks.NewMockLocker(ctrl) + gomock.InOrder( + locker.EXPECT().Lock().Return(nil), + locker.EXPECT().Locked().Return(true), + locker.EXPECT().Unlock().Return(nil), + ) + return locker + } + + mockTemplate := `{{/* docker-compose_base.tmpl */}} {{ define "docker-compose" }} services: service1: @@ -94,111 +94,111 @@ networks: {{ end }} ` - tests := []struct { - name string - env map[string]string - mocker func(*testing.T) *mocks.MockLocker - wantErr bool - }{ - { - name: "success", - env: map[string]string{ - "IMAGE": "myimage:latest", - "PORT": "8080", - }, - mocker: okLocker, - wantErr: false, - }, - { - name: "empty .env", - env: map[string]string{}, - mocker: okLocker, - wantErr: false, - }, - { - name: "unlock error", - env: map[string]string{ - "ERROR": "error", - }, - mocker: func(t *testing.T) *mocks.MockLocker { - ctrl := gomock.NewController(t) - locker := mocks.NewMockLocker(ctrl) - gomock.InOrder( - locker.EXPECT().Lock().Return(nil), - locker.EXPECT().Locked().Return(false), - ) - return locker - }, - wantErr: true, - }, - { - name: "lock error", - env: map[string]string{ - "ERROR": "error", - }, - mocker: func(t *testing.T) *mocks.MockLocker { - ctrl := gomock.NewController(t) - locker := mocks.NewMockLocker(ctrl) - locker.EXPECT().Lock().Return(errors.New("lock error")) - return locker - }, - wantErr: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - afs := afero.NewMemMapFs() - mockFs := &afero.MemMapFs{} - afero.WriteFile(mockFs, "services/docker-compose_base.tmpl", []byte(mockTemplate), 0644) - - stack := &MonitoringStack{ - path: "/", - l: tt.mocker(t), - fs: afs, - } - - err := stack.Setup(tt.env, afero.NewIOFS(mockFs)) - if tt.wantErr { - assert.Error(t, err) - return - } - assert.NoError(t, err) - - // Check .env file - exists, err := afero.Exists(afs, "/.env") - assert.NoError(t, err) - assert.True(t, exists) - - env, err := afero.ReadFile(afs, "/.env") - require.NoError(t, err) - gotEnv := make(map[string]string) - for _, line := range strings.Split(string(env), "\n") { - parts := strings.Split(line, "=") - if len(parts) == 2 { - gotEnv[parts[0]] = parts[1] - } - } - assert.EqualValues(t, tt.env, gotEnv) - - // Check docker-compose.yml - exists, err = afero.Exists(afs, "/docker-compose.yml") - assert.NoError(t, err) - assert.True(t, exists) - - gotCmp, err := afero.ReadFile(afs, "/docker-compose.yml") - require.NoError(t, err) - - // Parse the template with the test data - tmpl, err := template.New("test").Parse(mockTemplate) - require.NoError(t, err) - var expectedBuf bytes.Buffer - err = tmpl.ExecuteTemplate(&expectedBuf, "docker-compose", nil) - require.NoError(t, err) - - assert.Equal(t, expectedBuf.String(), string(gotCmp)) - }) - } + tests := []struct { + name string + env map[string]string + mocker func(*testing.T) *mocks.MockLocker + wantErr bool + }{ + { + name: "success", + env: map[string]string{ + "IMAGE": "myimage:latest", + "PORT": "8080", + }, + mocker: okLocker, + wantErr: false, + }, + { + name: "empty .env", + env: map[string]string{}, + mocker: okLocker, + wantErr: false, + }, + { + name: "unlock error", + env: map[string]string{ + "ERROR": "error", + }, + mocker: func(t *testing.T) *mocks.MockLocker { + ctrl := gomock.NewController(t) + locker := mocks.NewMockLocker(ctrl) + gomock.InOrder( + locker.EXPECT().Lock().Return(nil), + locker.EXPECT().Locked().Return(false), + ) + return locker + }, + wantErr: true, + }, + { + name: "lock error", + env: map[string]string{ + "ERROR": "error", + }, + mocker: func(t *testing.T) *mocks.MockLocker { + ctrl := gomock.NewController(t) + locker := mocks.NewMockLocker(ctrl) + locker.EXPECT().Lock().Return(errors.New("lock error")) + return locker + }, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + afs := afero.NewMemMapFs() + mockFs := &afero.MemMapFs{} + afero.WriteFile(mockFs, "services/docker-compose_base.tmpl", []byte(mockTemplate), 0o644) + + stack := &MonitoringStack{ + path: "/", + l: tt.mocker(t), + fs: afs, + } + + err := stack.Setup(tt.env, afero.NewIOFS(mockFs)) + if tt.wantErr { + assert.Error(t, err) + return + } + assert.NoError(t, err) + + // Check .env file + exists, err := afero.Exists(afs, "/.env") + assert.NoError(t, err) + assert.True(t, exists) + + env, err := afero.ReadFile(afs, "/.env") + require.NoError(t, err) + gotEnv := make(map[string]string) + for _, line := range strings.Split(string(env), "\n") { + parts := strings.Split(line, "=") + if len(parts) == 2 { + gotEnv[parts[0]] = parts[1] + } + } + assert.EqualValues(t, tt.env, gotEnv) + + // Check docker-compose.yml + exists, err = afero.Exists(afs, "/docker-compose.yml") + assert.NoError(t, err) + assert.True(t, exists) + + gotCmp, err := afero.ReadFile(afs, "/docker-compose.yml") + require.NoError(t, err) + + // Parse the template with the test data + tmpl, err := template.New("test").Parse(mockTemplate) + require.NoError(t, err) + var expectedBuf bytes.Buffer + err = tmpl.ExecuteTemplate(&expectedBuf, "docker-compose", nil) + require.NoError(t, err) + + assert.Equal(t, expectedBuf.String(), string(gotCmp)) + }) + } } func TestCreateDir(t *testing.T) { @@ -816,112 +816,112 @@ func TestPath(t *testing.T) { } func TestCleanup(t *testing.T) { - t.Parallel() - - tests := []struct { - name string - mocker func(*testing.T) (*mocks.MockLocker, afero.Fs) - force bool - notInstall bool - wantErr bool - }{ - { - name: "ok, force false", - mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { - ctrl := gomock.NewController(t) - locker := mocks.NewMockLocker(ctrl) - gomock.InOrder( - locker.EXPECT().New(utils.PathMatcher{Expected: filepath.Join("monitoring", ".lock")}).Return(locker), - locker.EXPECT().Lock().Return(nil), - locker.EXPECT().Locked().Return(true), - locker.EXPECT().Unlock().Return(nil), - ) - locker.EXPECT().Lock().Return(nil) - return locker, afero.NewMemMapFs() - }, - force: false, - }, - { - name: "ok, force true", - mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { - ctrl := gomock.NewController(t) - locker := mocks.NewMockLocker(ctrl) - gomock.InOrder( - locker.EXPECT().New(utils.PathMatcher{Expected: filepath.Join("monitoring", ".lock")}).Return(locker), - locker.EXPECT().Lock().Return(nil), - locker.EXPECT().Locked().Return(true), - locker.EXPECT().Unlock().Return(nil), - ) - return locker, afero.NewMemMapFs() - }, - force: true, - }, - { - name: "not installed", - mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { - ctrl := gomock.NewController(t) - locker := mocks.NewMockLocker(ctrl) - locker.EXPECT().Lock().Return(nil) - return locker, afero.NewMemMapFs() - }, - notInstall: true, - }, - { - name: "lock error", - mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { - ctrl := gomock.NewController(t) - locker := mocks.NewMockLocker(ctrl) - gomock.InOrder( - locker.EXPECT().New(utils.PathMatcher{Expected: filepath.Join("monitoring", ".lock")}).Return(locker), - locker.EXPECT().Lock().Return(nil), - locker.EXPECT().Locked().Return(true), - locker.EXPECT().Unlock().Return(nil), - ) - locker.EXPECT().Lock().Return(errors.New("lock error")) - return locker, afero.NewMemMapFs() - }, - wantErr: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - locker, fs := tt.mocker(t) - stack := &MonitoringStack{ - path: "/monitoring", - l: locker, - fs: fs, - } - - // Install the stack - var err error - if !tt.notInstall { - err = stack.Init() - require.NoError(t, err) - - // Write the template file to the in-memory filesystem - afero.WriteFile(fs, "services/docker-compose_base.tmpl", []byte(` + t.Parallel() + + tests := []struct { + name string + mocker func(*testing.T) (*mocks.MockLocker, afero.Fs) + force bool + notInstall bool + wantErr bool + }{ + { + name: "ok, force false", + mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { + ctrl := gomock.NewController(t) + locker := mocks.NewMockLocker(ctrl) + gomock.InOrder( + locker.EXPECT().New(utils.PathMatcher{Expected: filepath.Join("monitoring", ".lock")}).Return(locker), + locker.EXPECT().Lock().Return(nil), + locker.EXPECT().Locked().Return(true), + locker.EXPECT().Unlock().Return(nil), + ) + locker.EXPECT().Lock().Return(nil) + return locker, afero.NewMemMapFs() + }, + force: false, + }, + { + name: "ok, force true", + mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { + ctrl := gomock.NewController(t) + locker := mocks.NewMockLocker(ctrl) + gomock.InOrder( + locker.EXPECT().New(utils.PathMatcher{Expected: filepath.Join("monitoring", ".lock")}).Return(locker), + locker.EXPECT().Lock().Return(nil), + locker.EXPECT().Locked().Return(true), + locker.EXPECT().Unlock().Return(nil), + ) + return locker, afero.NewMemMapFs() + }, + force: true, + }, + { + name: "not installed", + mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { + ctrl := gomock.NewController(t) + locker := mocks.NewMockLocker(ctrl) + locker.EXPECT().Lock().Return(nil) + return locker, afero.NewMemMapFs() + }, + notInstall: true, + }, + { + name: "lock error", + mocker: func(t *testing.T) (*mocks.MockLocker, afero.Fs) { + ctrl := gomock.NewController(t) + locker := mocks.NewMockLocker(ctrl) + gomock.InOrder( + locker.EXPECT().New(utils.PathMatcher{Expected: filepath.Join("monitoring", ".lock")}).Return(locker), + locker.EXPECT().Lock().Return(nil), + locker.EXPECT().Locked().Return(true), + locker.EXPECT().Unlock().Return(nil), + ) + locker.EXPECT().Lock().Return(errors.New("lock error")) + return locker, afero.NewMemMapFs() + }, + wantErr: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + locker, fs := tt.mocker(t) + stack := &MonitoringStack{ + path: "/monitoring", + l: locker, + fs: fs, + } + + // Install the stack + var err error + if !tt.notInstall { + err = stack.Init() + require.NoError(t, err) + + // Write the template file to the in-memory filesystem + afero.WriteFile(fs, "services/docker-compose_base.tmpl", []byte(` services: {{.ServiceName}}: image: {{.Image}} ports: - "{{.Port}}:{{.Port}}" -`), 0644) - - err = stack.Setup(map[string]string{"ServiceName": "myservice", "Image": "myimage:latest", "Port": "8080"}, templates.Services) - require.NoError(t, err) - } - - err = stack.Cleanup(tt.force) - if tt.wantErr { - assert.Error(t, err) - } else { - assert.NoError(t, err) - // Check that monitoring stack has been removed - exists, err := afero.DirExists(fs, "/monitoring") - assert.NoError(t, err) - assert.False(t, exists) - } - }) - } +`), 0o644) + + err = stack.Setup(map[string]string{"ServiceName": "myservice", "Image": "myimage:latest", "Port": "8080"}, templates.Services) + require.NoError(t, err) + } + + err = stack.Cleanup(tt.force) + if tt.wantErr { + assert.Error(t, err) + } else { + assert.NoError(t, err) + // Check that monitoring stack has been removed + exists, err := afero.DirExists(fs, "/monitoring") + assert.NoError(t, err) + assert.False(t, exists) + } + }) + } } diff --git a/internal/monitoring/monitoring.go b/internal/monitoring/monitoring.go index 5bcb61a97..ce206e6c5 100644 --- a/internal/monitoring/monitoring.go +++ b/internal/monitoring/monitoring.go @@ -37,7 +37,6 @@ import ( funk "github.com/thoas/go-funk" ) - // MonitoringManager manages the monitoring services. It provides methods for initializing the monitoring stack, // adding and removing targets, running and stopping the monitoring stack, and checking the status of the monitoring stack. type MonitoringManager struct { @@ -113,7 +112,7 @@ func (m *MonitoringManager) InstallStack() error { // Merge all dotEnv dotEnv := make(map[string]string) defaultPorts := make(map[string]uint16) - + for _, service := range m.services { for k, v := range service.DotEnv() { dotEnv[k] = v @@ -249,7 +248,7 @@ func (m *MonitoringManager) Stop() error { // Status checks the status of the containers in the monitoring stack and returns the status. func (m *MonitoringManager) Status() (status common.Status, err error) { var containers []string - for _, service := range m.services{ + for _, service := range m.services { containers = append(containers, service.ContainerName()) } @@ -331,18 +330,18 @@ func (m *MonitoringManager) saveServiceIP() error { // AddService adds a new service to the monitoring stack dynamically. func (m *MonitoringManager) AddService(service ServiceAPI) error { - // Check if the service already exists - for _, existingService := range m.services { - if existingService.ContainerName() == service.ContainerName() { - return fmt.Errorf("service %s already exists", service.ContainerName()) - } - } + // Check if the service already exists + for _, existingService := range m.services { + if existingService.ContainerName() == service.ContainerName() { + return fmt.Errorf("service %s already exists", service.ContainerName()) + } + } - // Add the new service to the list - m.services = append(m.services, service) + // Add the new service to the list + m.services = append(m.services, service) - // Get the new service's environment variables - dotEnv := service.DotEnv() + // Get the new service's environment variables + dotEnv := service.DotEnv() // Initialize the new service if err := service.Init(types.ServiceOptions{ @@ -355,98 +354,97 @@ func (m *MonitoringManager) AddService(service ServiceAPI) error { if err := service.Setup(dotEnv); err != nil { return fmt.Errorf("failed to setup service %s: %w", service.Name(), err) } - - // Update the .env file in the stack - if err := m.updateEnvFile(dotEnv); err != nil { - return fmt.Errorf("failed to update .env file: %w", err) - } - // Update the docker-compose.yml file - if err := m.updateDockerComposeFile(service); err != nil { - return fmt.Errorf("failed to update docker-compose.yml: %w", err) - } + // Update the .env file in the stack + if err := m.updateEnvFile(dotEnv); err != nil { + return fmt.Errorf("failed to update .env file: %w", err) + } + + // Update the docker-compose.yml file + if err := m.updateDockerComposeFile(service); err != nil { + return fmt.Errorf("failed to update docker-compose.yml: %w", err) + } // Create and start the new service's container - if err := m.composeManager.Create(commands.DockerComposeCreateOptions{Path: filepath.Join(m.stack.Path(), "docker-compose.yml")}); err != nil { - return fmt.Errorf("failed to create service container: %w", err) - } + if err := m.composeManager.Create(commands.DockerComposeCreateOptions{Path: filepath.Join(m.stack.Path(), "docker-compose.yml")}); err != nil { + return fmt.Errorf("failed to create service container: %w", err) + } - if err := m.composeManager.Up(commands.DockerComposeUpOptions{Path: filepath.Join(m.stack.Path(), "docker-compose.yml")}); err != nil { - return fmt.Errorf("failed to start service container: %w", err) - } + if err := m.composeManager.Up(commands.DockerComposeUpOptions{Path: filepath.Join(m.stack.Path(), "docker-compose.yml")}); err != nil { + return fmt.Errorf("failed to start service container: %w", err) + } - // Save the new service's IP - if err := m.saveServiceIP(); err != nil { - return fmt.Errorf("failed to save service IP: %w", err) - } + // Save the new service's IP + if err := m.saveServiceIP(); err != nil { + return fmt.Errorf("failed to save service IP: %w", err) + } - return nil + return nil } // Helper method to update the .env file func (m *MonitoringManager) updateEnvFile(newEnv map[string]string) error { - currentEnv, err := m.stack.ReadFile(".env") - if err != nil { - return err - } - - // Parse current env - env := make(map[string]string) - for _, line := range bytes.Split(currentEnv, []byte("\n")) { - parts := bytes.SplitN(line, []byte("="), 2) - if len(parts) == 2 { - env[string(parts[0])] = string(parts[1]) - } - } - - // Merge new env - for k, v := range newEnv { - env[k] = v - } - - // Write updated env - var buf bytes.Buffer - for k, v := range env { - buf.WriteString(fmt.Sprintf("%s=%s\n", k, v)) - } - - return m.stack.WriteFile(".env", buf.Bytes()) + currentEnv, err := m.stack.ReadFile(".env") + if err != nil { + return err + } + + // Parse current env + env := make(map[string]string) + for _, line := range bytes.Split(currentEnv, []byte("\n")) { + parts := bytes.SplitN(line, []byte("="), 2) + if len(parts) == 2 { + env[string(parts[0])] = string(parts[1]) + } + } + + // Merge new env + for k, v := range newEnv { + env[k] = v + } + + // Write updated env + var buf bytes.Buffer + for k, v := range env { + buf.WriteString(fmt.Sprintf("%s=%s\n", k, v)) + } + + return m.stack.WriteFile(".env", buf.Bytes()) } // Helper method to update the docker-compose.yml file func (m *MonitoringManager) updateDockerComposeFile(service ServiceAPI) error { + // Read the main Docker Compose template + rawBaseTmp, err := templates.Services.ReadFile(filepath.Join("services", "docker-compose_base.tmpl")) + if err != nil { + return err + } + + baseTmp, err := template.New("docker-compose").Parse(string(rawBaseTmp)) + if err != nil { + return err + } + + serviceTmp, err := templates.Services.ReadFile(filepath.Join("services", service.Name()+".tmpl")) + if err != nil { + return fmt.Errorf("error reading lido_exporter template: %w", err) + } + + baseTmp, err = baseTmp.Parse(string(serviceTmp)) + if err != nil { + return fmt.Errorf("error parsing service %s template: %w", service.Name(), err) + } + + // Create a buffer to hold the merged content + var buf bytes.Buffer - // Read the main Docker Compose template - rawBaseTmp, err := templates.Services.ReadFile(filepath.Join("services", "docker-compose_base.tmpl")) - if err != nil { - return err - } - - baseTmp, err := template.New("docker-compose").Parse(string(rawBaseTmp)) - if err != nil { - return err - } - - serviceTmp, err := templates.Services.ReadFile(filepath.Join("services",service.Name()+".tmpl")) - if err != nil { - return fmt.Errorf("error reading lido_exporter template: %w", err) - } - - baseTmp, err = baseTmp.Parse(string(serviceTmp)) - if err != nil { - return fmt.Errorf("error parsing service %s template: %w", service.Name(),err) - } - - // Create a buffer to hold the merged content - var buf bytes.Buffer - - data:= types.ServiceTemplateData{ + data := types.ServiceTemplateData{ LidoExporter: service.Name() == LidoExporterServiceName, } - // Execute the main template with the service template as data - if err := baseTmp.Execute(&buf, data); err != nil { - return err + // Execute the main template with the service template as data + if err := baseTmp.Execute(&buf, data); err != nil { + return err } - // Write the merged content to the final Docker Compose file - return os.WriteFile(filepath.Join(m.stack.Path(), "docker-compose.yml"), buf.Bytes(), 0644) + // Write the merged content to the final Docker Compose file + return os.WriteFile(filepath.Join(m.stack.Path(), "docker-compose.yml"), buf.Bytes(), 0o644) } diff --git a/internal/monitoring/monitoring_test.go b/internal/monitoring/monitoring_test.go index 241e80fbb..66939264a 100644 --- a/internal/monitoring/monitoring_test.go +++ b/internal/monitoring/monitoring_test.go @@ -1670,7 +1670,6 @@ func TestServiceEndpoints(t *testing.T) { assert.Equal(t, want, endpoints) } - func TestAddService(t *testing.T) { // Silence logger log.SetOutput(io.Discard) @@ -1713,9 +1712,9 @@ func TestAddService(t *testing.T) { dockerServiceManager.EXPECT().ContainerIP("new-service").Return("172.0.0.2", nil) // Mock the template files - err := afero.WriteFile(fs, filepath.Join(userDataHome, ".sedge", "monitoring", ".env"), []byte("EXISTING_VAR=value"), 0644) + err := afero.WriteFile(fs, filepath.Join(userDataHome, ".sedge", "monitoring", ".env"), []byte("EXISTING_VAR=value"), 0o644) require.NoError(t, err) - err = afero.WriteFile(fs, filepath.Join(userDataHome, ".sedge", "monitoring", "docker-compose.yml"), []byte("version: '3'"), 0644) + err = afero.WriteFile(fs, filepath.Join(userDataHome, ".sedge", "monitoring", "docker-compose.yml"), []byte("version: '3'"), 0o644) require.NoError(t, err) manager := NewMonitoringManager( @@ -1756,7 +1755,6 @@ func TestAddService(t *testing.T) { }, wantErr: true, }, - } for _, tt := range tests { @@ -1825,7 +1823,7 @@ func TestUpdateEnvFile(t *testing.T) { mockLocker, ) - err := afero.WriteFile(fs, filepath.Join(manager.stack.Path(), ".env"), []byte(tt.initialEnv), 0644) + err := afero.WriteFile(fs, filepath.Join(manager.stack.Path(), ".env"), []byte(tt.initialEnv), 0o644) require.NoError(t, err) err = manager.updateEnvFile(tt.newEnv) @@ -1898,7 +1896,7 @@ networks: sedge: name: sedge-network external: true` - err := afero.WriteFile(fs, filepath.Join(manager.stack.Path(), "docker-compose.yml"), []byte(initialContent), 0644) + err := afero.WriteFile(fs, filepath.Join(manager.stack.Path(), "docker-compose.yml"), []byte(initialContent), 0o644) require.NoError(t, err) err = manager.updateDockerComposeFile(service) @@ -1921,4 +1919,4 @@ networks: } }) } -} \ No newline at end of file +} diff --git a/internal/monitoring/services/lido_exporter/dotenv.go b/internal/monitoring/services/lido_exporter/dotenv.go index 2a37b8897..2d987cbf7 100644 --- a/internal/monitoring/services/lido_exporter/dotenv.go +++ b/internal/monitoring/services/lido_exporter/dotenv.go @@ -16,13 +16,13 @@ limitations under the License. package lido_exporter var dotEnv map[string]string = map[string]string{ - "LIDO_EXPORTER_IMAGE": "nethermindeth/lido-exporter:v1.0.0", - "LIDO_EXPORTER_PORT": "8080", - "LIDO_EXPORTER_NODE_OPERATOR_ID": "", - "LIDO_EXPORTER_REWARD_ADDRESS": "", - "LIDO_EXPORTER_NETWORK": "", - "LIDO_EXPORTER_RPC_ENDPOINTS": "", - "LIDO_EXPORTER_WS_ENDPOINTS": "", - "LIDO_EXPORTER_SCRAPE_TIME": "", - "LIDO_EXPORTER_LOG_LEVEL": "", -} \ No newline at end of file + "LIDO_EXPORTER_IMAGE": "nethermindeth/lido-exporter:v1.0.0", + "LIDO_EXPORTER_PORT": "8080", + "LIDO_EXPORTER_NODE_OPERATOR_ID": "", + "LIDO_EXPORTER_REWARD_ADDRESS": "", + "LIDO_EXPORTER_NETWORK": "", + "LIDO_EXPORTER_RPC_ENDPOINTS": "", + "LIDO_EXPORTER_WS_ENDPOINTS": "", + "LIDO_EXPORTER_SCRAPE_TIME": "", + "LIDO_EXPORTER_LOG_LEVEL": "", +} diff --git a/internal/monitoring/services/lido_exporter/service.go b/internal/monitoring/services/lido_exporter/service.go index 1fa94847a..76cf26008 100644 --- a/internal/monitoring/services/lido_exporter/service.go +++ b/internal/monitoring/services/lido_exporter/service.go @@ -29,19 +29,18 @@ import ( var _ monitoring.ServiceAPI = &LidoExporterService{} type LidoExporterParams struct { - NodeOperatorID string - RewardAddress string - Network string - RPCEndpoints []string - WSEndpoints []string - Port uint16 - ScrapeTime time.Duration - LogLevel string + NodeOperatorID string + RewardAddress string + Network string + RPCEndpoints []string + WSEndpoints []string + Port uint16 + ScrapeTime time.Duration + LogLevel string } - type LidoExporterService struct { - containerIP net.IP + containerIP net.IP params LidoExporterParams } @@ -55,9 +54,9 @@ func NewLidoExporter(params LidoExporterParams) *LidoExporterService { dotEnv["LIDO_EXPORTER_SCRAPE_TIME"] = params.ScrapeTime.String() dotEnv["LIDO_EXPORTER_LOG_LEVEL"] = params.LogLevel - return &LidoExporterService{ - params: params, - } + return &LidoExporterService{ + params: params, + } } func (n *LidoExporterService) Init(opts types.ServiceOptions) error { @@ -107,4 +106,4 @@ func (l *LidoExporterService) Endpoint() string { func (l *LidoExporterService) Name() string { return monitoring.LidoExporterServiceName -} \ No newline at end of file +} diff --git a/internal/monitoring/services/node_exporter/service.go b/internal/monitoring/services/node_exporter/service.go index bca1c931f..15fd8d260 100644 --- a/internal/monitoring/services/node_exporter/service.go +++ b/internal/monitoring/services/node_exporter/service.go @@ -82,4 +82,4 @@ func (n *NodeExporterService) Endpoint() string { func (n *NodeExporterService) Name() string { return monitoring.NodeExporterServiceName -} \ No newline at end of file +} diff --git a/internal/monitoring/services/prometheus/service.go b/internal/monitoring/services/prometheus/service.go index ac329bf0c..55789a8f2 100644 --- a/internal/monitoring/services/prometheus/service.go +++ b/internal/monitoring/services/prometheus/service.go @@ -306,4 +306,4 @@ func (p *PrometheusService) reloadConfig() error { func (p *PrometheusService) Name() string { return monitoring.PrometheusServiceName -} \ No newline at end of file +} diff --git a/internal/monitoring/services/templates/templates.go b/internal/monitoring/services/templates/templates.go index f62819e85..acc561eff 100644 --- a/internal/monitoring/services/templates/templates.go +++ b/internal/monitoring/services/templates/templates.go @@ -18,4 +18,4 @@ package templates import "embed" //go:embed services -var Services embed.FS \ No newline at end of file +var Services embed.FS diff --git a/internal/monitoring/services/types/types.go b/internal/monitoring/services/types/types.go index 714be20dc..d0313ddb0 100644 --- a/internal/monitoring/services/types/types.go +++ b/internal/monitoring/services/types/types.go @@ -51,4 +51,4 @@ func (t MonitoringTarget) Endpoint() string { // ServiceTemplateData: Struct Data object to be applied to docker-compose script type ServiceTemplateData struct { LidoExporter bool -} \ No newline at end of file +} diff --git a/internal/pkg/services/gomock_reflect_1452349235/prog.go b/internal/pkg/services/gomock_reflect_1452349235/prog.go deleted file mode 100644 index 0a09b26ce..000000000 --- a/internal/pkg/services/gomock_reflect_1452349235/prog.go +++ /dev/null @@ -1,66 +0,0 @@ - -package main - -import ( - "encoding/gob" - "flag" - "fmt" - "os" - "path" - "reflect" - - "github.com/golang/mock/mockgen/model" - - pkg_ "github.com/docker/docker/client" -) - -var output = flag.String("output", "", "The output file name, or empty to use stdout.") - -func main() { - flag.Parse() - - its := []struct{ - sym string - typ reflect.Type - }{ - - { "APIClient", reflect.TypeOf((*pkg_.APIClient)(nil)).Elem()}, - - } - pkg := &model.Package{ - // NOTE: This behaves contrary to documented behaviour if the - // package name is not the final component of the import path. - // The reflect package doesn't expose the package name, though. - Name: path.Base("github.com/docker/docker/client"), - } - - for _, it := range its { - intf, err := model.InterfaceFromInterfaceType(it.typ) - if err != nil { - fmt.Fprintf(os.Stderr, "Reflection: %v\n", err) - os.Exit(1) - } - intf.Name = it.sym - pkg.Interfaces = append(pkg.Interfaces, intf) - } - - outfile := os.Stdout - if len(*output) != 0 { - var err error - outfile, err = os.Create(*output) - if err != nil { - fmt.Fprintf(os.Stderr, "failed to open output file %q", *output) - } - defer func() { - if err := outfile.Close(); err != nil { - fmt.Fprintf(os.Stderr, "failed to close output file %q", *output) - os.Exit(1) - } - }() - } - - if err := gob.NewEncoder(outfile).Encode(pkg); err != nil { - fmt.Fprintf(os.Stderr, "gob encode: %v\n", err) - os.Exit(1) - } -}