113 lines
3.3 KiB
Go
113 lines
3.3 KiB
Go
// Package application wires configuration, product collectors and the HTTP server together.
|
|
package application
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/prometheus/client_golang/prometheus/promhttp"
|
|
log "github.com/sirupsen/logrus"
|
|
"lostak.dev/shelly-exporter/collector"
|
|
"lostak.dev/shelly-exporter/configuration"
|
|
"lostak.dev/shelly-exporter/shelly"
|
|
)
|
|
|
|
// Application is a configured Shelly exporter HTTP server.
|
|
type Application struct {
|
|
config *configuration.Configuration
|
|
registry *prometheus.Registry
|
|
server *http.Server
|
|
}
|
|
|
|
// New loads a configuration and registers one collector per Shelly device.
|
|
func New(configPath string) (*Application, error) {
|
|
config, err := configuration.Load(configPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
log.SetLevel(log.AllLevels[config.LogLevel])
|
|
|
|
registry := prometheus.NewRegistry()
|
|
deviceCollectors := make(collector.Group, 0, len(config.Shelly.Devices))
|
|
for _, device := range config.Shelly.Devices {
|
|
client, err := shelly.NewClient(
|
|
device.URL,
|
|
device.Username,
|
|
device.Password,
|
|
time.Duration(config.Shelly.TimeoutSeconds)*time.Second,
|
|
)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create client for device %q: %w", device.Name, err)
|
|
}
|
|
|
|
deviceCollector, err := collector.NewDeviceCollector(device, client)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("configure device %q: %w", device.Name, err)
|
|
}
|
|
deviceCollectors = append(deviceCollectors, deviceCollector)
|
|
log.Infof("Registered %s metrics for Shelly device %q.", device.Product, device.Name)
|
|
}
|
|
if err := registry.Register(deviceCollectors); err != nil {
|
|
return nil, fmt.Errorf("register device metrics: %w", err)
|
|
}
|
|
|
|
mux := http.NewServeMux()
|
|
mux.Handle("/metrics", promhttp.HandlerFor(registry, promhttp.HandlerOpts{EnableOpenMetrics: true}))
|
|
mux.HandleFunc("/-/healthy", func(response http.ResponseWriter, _ *http.Request) {
|
|
response.WriteHeader(http.StatusOK)
|
|
_, _ = response.Write([]byte("OK\n"))
|
|
})
|
|
|
|
address := fmt.Sprintf("%s:%d", config.Host, config.Port)
|
|
return &Application{
|
|
config: config,
|
|
registry: registry,
|
|
server: &http.Server{
|
|
Addr: address,
|
|
Handler: mux,
|
|
ReadHeaderTimeout: 5 * time.Second,
|
|
ReadTimeout: 15 * time.Second,
|
|
WriteTimeout: 30 * time.Second,
|
|
IdleTimeout: 60 * time.Second,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// Run serves metrics until the context is cancelled or the server fails.
|
|
func (app *Application) Run(ctx context.Context) error {
|
|
listener, err := net.Listen("tcp", app.server.Addr)
|
|
if err != nil {
|
|
return fmt.Errorf("listen on %s: %w", app.server.Addr, err)
|
|
}
|
|
|
|
serverError := make(chan error, 1)
|
|
log.Infof("Shelly exporter started on %s.", listener.Addr())
|
|
go func() {
|
|
serverError <- app.server.Serve(listener)
|
|
}()
|
|
|
|
select {
|
|
case err := <-serverError:
|
|
if errors.Is(err, http.ErrServerClosed) {
|
|
return nil
|
|
}
|
|
return err
|
|
case <-ctx.Done():
|
|
shutdownContext, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if err := app.server.Shutdown(shutdownContext); err != nil {
|
|
return fmt.Errorf("shut down HTTP server: %w", err)
|
|
}
|
|
err = <-serverError
|
|
if err != nil && !errors.Is(err, http.ErrServerClosed) {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
}
|