chore: using exporter-toolkit/web for web config

Signed-off-by: SamYuan1990 <[email protected]>

Author: SamYuan1990

config/config.go

@@ -11,6 +11,8 @@ import (
 	"time"
 
 	"github.com/alecthomas/kingpin/v2"
+	"github.com/prometheus/exporter-toolkit/web"
+	"github.com/prometheus/exporter-toolkit/web/kingpinflag"
 	"gopkg.in/yaml.v3"
 	"k8s.io/utils/ptr"
 )
@@ -39,7 +41,7 @@ type (
 		} `yaml:"fake-cpu-meter"`
 	}
 	Web struct {
-		Config string `yaml:"configFile"`
+		Config *web.FlagConfig
 	}
 
 	Monitor struct {
@@ -83,9 +85,9 @@ type (
 		Monitor  Monitor  `yaml:"monitor"`
 		Rapl     Rapl     `yaml:"rapl"`
 		Exporter Exporter `yaml:"exporter"`
-		Web      Web      `yaml:"web"`
-		Debug    Debug    `yaml:"debug"`
-		Dev      Dev      `yaml:"dev"` // WARN: do not expose dev settings as flags
+		Web      Web
+		Debug    Debug `yaml:"debug"`
+		Dev      Dev   `yaml:"dev"` // WARN: do not expose dev settings as flags
 
 		Kube Kube `yaml:"kube"`
 	}
@@ -99,6 +101,7 @@ const (
 )
 
 const (
+	DefaultPort = ":28282"
 	// Flags
 	LogLevelFlag  = "log.level"
 	LogFormatFlag = "log.format"
@@ -133,6 +136,7 @@ const (
 
 // DefaultConfig returns a Config with default values
 func DefaultConfig() *Config {
+	TLSconfig := ""
 	cfg := &Config{
 		Log: Log{
 			Level:  "info",
@@ -166,6 +170,12 @@ func DefaultConfig() *Config {
 		Kube: Kube{
 			Enabled: ptr.To(false),
 		},
+		Web: Web{
+			Config: &web.FlagConfig{
+				WebListenAddresses: &[]string{DefaultPort},
+				WebConfigFile:      &TLSconfig,
+			},
+		},
 	}
 
 	cfg.Dev.FakeCpuMeter.Enabled = ptr.To(false)
@@ -245,7 +255,8 @@ func RegisterFlags(app *kingpin.Application) ConfigUpdaterFn {
 		"Interval for monitoring resources (processes, container, vm, etc...); 0 to disable").Default("5s").Duration()
 
 	enablePprof := app.Flag(pprofEnabledFlag, "Enable pprof debug endpoints").Default("false").Bool()
-	webConfig := app.Flag(WebConfigFlag, "Web config file path").Default("").String()
+	//webConfig using github.com/prometheus/exporter-toolkit/web/
+	webConfig := kingpinflag.AddFlags(app, DefaultPort)
 
 	// exporters
 	stdoutExporterEnabled := app.Flag(ExporterStdoutEnabledFlag, "Enable stdout exporter").Default("false").Bool()
@@ -284,7 +295,7 @@ func RegisterFlags(app *kingpin.Application) ConfigUpdaterFn {
 		}
 
 		if flagsSet[WebConfigFlag] {
-			cfg.Web.Config = *webConfig
+			cfg.Web.Config = webConfig
 		}
 
 		if flagsSet[ExporterStdoutEnabledFlag] {
@@ -317,7 +328,6 @@ func (c *Config) sanitize() {
 	c.Log.Format = strings.TrimSpace(c.Log.Format)
 	c.Host.SysFS = strings.TrimSpace(c.Host.SysFS)
 	c.Host.ProcFS = strings.TrimSpace(c.Host.ProcFS)
-	c.Web.Config = strings.TrimSpace(c.Web.Config)
 
 	for i := range c.Rapl.Zones {
 		c.Rapl.Zones[i] = strings.TrimSpace(c.Rapl.Zones[i])
@@ -359,7 +369,13 @@ func (c *Config) Validate(skips ...SkipValidation) error {
 			errs = append(errs, fmt.Sprintf("invalid log format: %s", c.Log.Format))
 		}
 	}
-
+	{ // Web config file
+		if *c.Web.Config.WebConfigFile != "" {
+			if err := canReadFile(*c.Web.Config.WebConfigFile); err != nil {
+				errs = append(errs, fmt.Sprintf("invalid web config file. path: %q: %s", *c.Web.Config.WebConfigFile, err.Error()))
+			}
+		}
+	}
 	{ // Validate host settings
 		if _, skip := validationSkipped[SkipHostValidation]; !skip {
 			if err := canReadDir(c.Host.SysFS); err != nil {
@@ -370,13 +386,6 @@ func (c *Config) Validate(skips ...SkipValidation) error {
 			}
 		}
 	}
-	{ // Web config file
-		if c.Web.Config != "" {
-			if err := canReadFile(c.Web.Config); err != nil {
-				errs = append(errs, fmt.Sprintf("invalid web config file. path: %q: %s", c.Web.Config, err.Error()))
-			}
-		}
-	}
 	{ // Monitor
 		if c.Monitor.Interval < 0 {
 			errs = append(errs, fmt.Sprintf("invalid monitor interval: %s can't be negative", c.Monitor.Interval))

config/config_test.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/alecthomas/kingpin/v2"
+	"github.com/prometheus/exporter-toolkit/web"
 	"github.com/stretchr/testify/assert"
 	"k8s.io/utils/ptr"
 )
@@ -22,7 +23,10 @@ func TestDefaultConfig(t *testing.T) {
 	// Assert default values are set correctly
 	assert.Equal(t, "info", cfg.Log.Level)
 	assert.Equal(t, "text", cfg.Log.Format)
-	assert.Equal(t, "", cfg.Web.Config)
+	addrs := *cfg.Web.Config.WebListenAddresses
+	addr := addrs[0]
+	assert.Equal(t, DefaultPort, addr)
+	assert.Equal(t, "", *cfg.Web.Config.WebConfigFile)
 }
 
 func TestLoadFromYAML(t *testing.T) {
@@ -216,6 +220,7 @@ func TestReadError(t *testing.T) {
 func TestInvalidConfigurationValues(t *testing.T) {
 	// Test validation of configuration values (command line and YAML)
 	// Create a kingpin app and register flags
+	unreadableWebConfig := "/from/unreadable/path/web.yaml"
 	tt := []struct {
 		name   string
 		config *Config
@@ -288,7 +293,9 @@ func TestInvalidConfigurationValues(t *testing.T) {
 		name: "unreadable web config",
 		config: &Config{
 			Web: Web{
-				Config: "/from/unreadable/path/web.yaml",
+				Config: &web.FlagConfig{
+					WebConfigFile: &unreadableWebConfig,
+				},
 			},
 		},
 		error: "invalid web config file",
@@ -367,6 +374,7 @@ func TestConfigValidation(t *testing.T) {
 }
 
 func TestConfigString(t *testing.T) {
+	fackWebConfig := "/fake/web.config.yml"
 	tt := []struct {
 		name   string
 		config *Config
@@ -404,7 +412,9 @@ func TestConfigString(t *testing.T) {
 		name: "custom web.config",
 		config: &Config{
 			Web: Web{
-				Config: "/fake/web.config.yml",
+				Config: &web.FlagConfig{
+					WebConfigFile: &fackWebConfig,
+				},
 			},
 		},
 	}}

internal/server/server.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/prometheus/exporter-toolkit/web"
+	"github.com/sustainable-computing-io/kepler/config"
 	"github.com/sustainable-computing-io/kepler/internal/service"
 )
 
@@ -23,22 +24,19 @@ type APIService interface {
 // APIServer implements APIServer
 type APIServer struct {
 	// input
-	logger      *slog.Logger
-	listenAddrs []string
-
+	logger *slog.Logger
 	// http
 	server              *http.Server
 	mux                 *http.ServeMux
 	endpointDescription string
-	webCfgPath          string
+	webConfig           *web.FlagConfig
 }
 
 var _ APIService = (*APIServer)(nil)
 
 type Opts struct {
-	logger      *slog.Logger
-	listenAddrs []string
-	webCfgPath  string
+	logger    *slog.Logger
+	webConfig *web.FlagConfig
 }
 
 // OptionFn is a function sets one more more options in Opts struct
@@ -51,25 +49,31 @@ func WithLogger(logger *slog.Logger) OptionFn {
 	}
 }
 
-// WithListenAddress sets the listening addresses for the APIServer
-func WithListenAddress(addr []string) OptionFn {
+// WithListen sets the listening addresses and webconfig path for the APIServer
+func WithListen(addr []string, path string) OptionFn {
 	return func(o *Opts) {
-		o.listenAddrs = addr
+		o.webConfig = &web.FlagConfig{
+			WebListenAddresses: &addr,
+			WebConfigFile:      &path,
+		}
 	}
 }
 
-func WithWebConfig(path string) OptionFn {
+func WithWebConfig(Config *web.FlagConfig) OptionFn {
 	return func(o *Opts) {
-		o.webCfgPath = path
+		o.webConfig = Config
 	}
 }
 
 // DefaultOpts returns the default options
 func DefaultOpts() Opts {
+	TLSconfig := ""
 	return Opts{
-		logger:      slog.Default(),
-		listenAddrs: []string{":28282"}, // Default HTTP Port
-		webCfgPath:  "",                 // Not present by default
+		logger: slog.Default(),
+		webConfig: &web.FlagConfig{
+			WebListenAddresses: &[]string{config.DefaultPort},
+			WebConfigFile:      &TLSconfig,
+		},
 	}
 }
 
@@ -85,11 +89,10 @@ func NewAPIServer(applyOpts ...OptionFn) *APIServer {
 		Handler: mux,
 	}
 	apiServer := &APIServer{
-		logger:      opts.logger.With("service", "api-server"),
-		listenAddrs: opts.listenAddrs,
-		mux:         mux,
-		server:      server,
-		webCfgPath:  opts.webCfgPath,
+		logger:    opts.logger.With("service", "api-server"),
+		mux:       mux,
+		server:    server,
+		webConfig: opts.webConfig,
 	}
 
 	return apiServer
@@ -100,11 +103,7 @@ func (s *APIServer) Name() string {
 }
 
 func (s *APIServer) Init() error {
-	s.logger.Info("Initializing HTTP server", "listening-on", s.listenAddrs)
-	if len(s.listenAddrs) == 0 {
-		return fmt.Errorf("no listening address provided")
-	}
-
+	s.logger.Info("Initializing kepler server")
 	// create landing page that shows all available endpoints
 	s.mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		// Only respond to the root path
@@ -134,23 +133,19 @@ func (s *APIServer) Init() error {
 }
 
 func (s *APIServer) Run(ctx context.Context) error {
-	s.logger.Info("Running HTTP server", "listening-on", s.listenAddrs)
+	s.logger.Info("Running kepler server")
 	errCh := make(chan error)
 	go func() {
-		webCfg := &web.FlagConfig{
-			WebListenAddresses: &s.listenAddrs,
-			WebConfigFile:      &s.webCfgPath,
-		}
-		errCh <- web.ListenAndServe(s.server, webCfg, s.logger)
+		errCh <- web.ListenAndServe(s.server, s.webConfig, s.logger)
 	}()
 
 	select {
 	case <-ctx.Done():
-		s.logger.Info("shutting down HTTP server on context done")
+		s.logger.Info("shutting down kepler server on context done")
 		return nil
 
 	case err := <-errCh:
-		s.logger.Error("HTTP server returned an error", "error", err)
+		s.logger.Error("kepler server returned an error", "error", err)
 		return err
 	}
 }

internal/server/server_test.go

@@ -60,14 +60,14 @@ func TestNewAPIServer(t *testing.T) {
 	}, {
 		name: "with custom listen address",
 		opts: []OptionFn{
-			WithListenAddress([]string{":8080", ":8081"}),
+			WithListen([]string{":8080", ":8081"}, ""),
 		},
 		serviceName: "api-server",
 	}, {
 		name: "with multiple options",
 		opts: []OptionFn{
 			WithLogger(slog.Default().With("test", "custom")),
-			WithListenAddress([]string{":9090"}),
+			WithListen([]string{":9090"}, ""),
 		},
 		serviceName: "api-server",
 	}}
@@ -85,11 +85,10 @@ func TestNewAPIServer(t *testing.T) {
 	// check listen address
 	{
 		server := NewAPIServer(
-			WithListenAddress([]string{":8080", ":8081"}),
+			WithListen([]string{":8080", ":8081"}, ""),
 		)
 
 		assert.NotNil(t, server)
-		assert.Equal(t, []string{":8080", ":8081"}, server.listenAddrs)
 	}
 }
 
@@ -167,13 +166,6 @@ func TestAPIServer_Register(t *testing.T) {
 	})
 }
 
-func TestAPIServer_InitWithNoListenAddr(t *testing.T) {
-	server := NewAPIServer(WithListenAddress([]string{}))
-	err := server.Init()
-	assert.Error(t, err, "Init should fail with no listen address")
-	assert.Contains(t, err.Error(), "no listening address provided")
-}
-
 func TestAPIServer_InitWithContextCancellation(t *testing.T) {
 	server := NewAPIServer()
 
@@ -247,7 +239,7 @@ func TestAPIServer_PortConflict(t *testing.T) {
 	})
 
 	// Create our API server with the same port
-	apiServer := NewAPIServer(WithListenAddress([]string{addr}))
+	apiServer := NewAPIServer(WithListen([]string{addr}, ""))
 
 	// Initing the API server on the same port should fail due to port conflict
 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
@@ -281,7 +273,7 @@ func TestAPIServer_RootEndpoint(t *testing.T) {
 
 	addr := fmt.Sprintf("127.0.0.1:%d", port)
 
-	server := NewAPIServer(WithListenAddress([]string{addr}))
+	server := NewAPIServer(WithListen([]string{addr}, ""))
 	assert.NoError(t, server.Init())
 
 	testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {