Adds power exporter

2022-11-26 15:33:23 -06:00
parent 021441b708
commit 5a25bb1c09
9 changed files with 633 additions and 11 deletions
--- a/cmd/export/config.go
+++ b/cmd/export/config.go
@@ -0,0 +1,333 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/logutils"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type config struct {
+	// time configuration
+	TimeFormat    string         `env:"TIME_FORMAT" default:"2006-01-02 15:04:05"`
+	TimeZoneLocal string         `env:"TIME_ZONE" default:"America/Chicago"`
+	TZoneLocal    *time.Location `ignored:"true"`
+	TZoneUTC      *time.Location `ignored:"true"`
+
+	// logging
+	LogLevel int                   `env:"LOG_LEVEL" default:"20"`
+	Log      *logutils.LevelFilter `ignored:"true"`
+
+	// webserver
+	WebSrvPort         int    `env:"WEBSRV_PORT" default:"8080"`
+	WebSrvIP           string `env:"WEBSRV_IP" default:"0.0.0.0"`
+	WebSrvReadTimeout  int    `env:"WEBSRV_TO_READ" default:"5"`
+	WebSrvWriteTimeout int    `env:"WEBSRV_TO_WRITE" default:"2"`
+	WebSrvIdleTimeout  int    `env:"WEBSRV_TO_READ" default:"2"`
+
+	// devices
+	Hosts []string `ignored:"true"`
+
+	// prometheus
+	Prometheus configPrometheus `ignored:"true"`
+}
+
+type hostStruct []string
+
+func (i *hostStruct) String() string {
+	return "dunno"
+}
+func (i *hostStruct) Set(value string) error {
+	*i = append(*i, value)
+	return nil
+}
+
+type structInfo struct {
+	Name         string
+	Alt          string
+	Key          string
+	Field        reflect.Value
+	Tags         reflect.StructTag
+	Type         reflect.Type
+	DefaultValue interface{}
+}
+
+type configPrometheus struct {
+	CurrentMa *prometheus.GaugeVec
+	VoltageMv *prometheus.GaugeVec
+	PowerMw   *prometheus.GaugeVec
+}
+
+func defaultConfig() *config {
+	return &config{
+		Log: &logutils.LevelFilter{
+			Levels: []logutils.LogLevel{"TRACE", "DEBUG", "INFO", "WARNING", "ERROR"},
+			Writer: os.Stderr,
+		},
+		Prometheus: configPrometheus{
+			CurrentMa: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+				Namespace: "tplink",
+				Name:      "unknown",
+				Help:      "unknown",
+			}, []string{"device"}),
+			VoltageMv: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+				Namespace: "tplink",
+				Name:      "volts",
+				Help:      "input voltage",
+			}, []string{"device"}),
+			PowerMw: prometheus.NewGaugeVec(prometheus.GaugeOpts{
+				Namespace: "tplink",
+				Name:      "watts",
+				Help:      "current wattage",
+			}, []string{"device"}),
+		},
+	}
+}
+
+func (cfg *config) setLogLevel() {
+	switch {
+	case cfg.LogLevel <= 20:
+		cfg.Log.SetMinLevel(logutils.LogLevel("ERROR"))
+	case cfg.LogLevel > 20 && cfg.LogLevel <= 40:
+		cfg.Log.SetMinLevel(logutils.LogLevel("WARNING"))
+	case cfg.LogLevel > 40 && cfg.LogLevel <= 60:
+		cfg.Log.SetMinLevel(logutils.LogLevel("INFO"))
+	case cfg.LogLevel > 60 && cfg.LogLevel <= 80:
+		cfg.Log.SetMinLevel(logutils.LogLevel("DEBUG"))
+	case cfg.LogLevel > 80:
+		cfg.Log.SetMinLevel(logutils.LogLevel("TRACE"))
+	}
+	log.SetOutput(cfg.Log)
+}
+
+func (cfg *config) printRunningConfig(cfgInfo []structInfo) {
+	log.Printf("[DEBUG] Current Running configuration Values:")
+	for _, info := range cfgInfo {
+		switch info.Type.String() {
+		case "string":
+			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*string)
+			log.Printf("[DEBUG]\t%s\t\t= %s\n", info.Alt, *p)
+		case "bool":
+			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*bool)
+			log.Printf("[DEBUG]\t%s\t\t= %s\n", info.Alt, strconv.FormatBool(*p))
+		case "int":
+			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*int)
+			log.Printf("[DEBUG]\t%s\t\t= %s\n", info.Alt, strconv.FormatInt(int64(*p), 10))
+		}
+	}
+}
+
+func getStructInfo(spec interface{}) ([]structInfo, error) {
+	s := reflect.ValueOf(spec)
+
+	if s.Kind() != reflect.Pointer {
+		return []structInfo{}, fmt.Errorf("getstructInfo() was sent a %s instead of a pointer to a struct.\n", s.Kind())
+	}
+
+	s = s.Elem()
+	if s.Kind() != reflect.Struct {
+		return []structInfo{}, fmt.Errorf("getstructInfo() was sent a %s instead of a struct.\n", s.Kind())
+	}
+	typeOfSpec := s.Type()
+
+	infos := make([]structInfo, 0, s.NumField())
+	for i := 0; i < s.NumField(); i++ {
+		f := s.Field(i)
+		ftype := typeOfSpec.Field(i)
+
+		ignored, _ := strconv.ParseBool(ftype.Tag.Get("ignored"))
+		if !f.CanSet() || ignored {
+			continue
+		}
+
+		for f.Kind() == reflect.Pointer {
+			if f.IsNil() {
+				if f.Type().Elem().Kind() != reflect.Struct {
+					break
+				}
+				f.Set(reflect.New(f.Type().Elem()))
+			}
+			f = f.Elem()
+		}
+
+		info := structInfo{
+			Name:  ftype.Name,
+			Alt:   strings.ToUpper(ftype.Tag.Get("env")),
+			Key:   ftype.Name,
+			Field: f,
+			Tags:  ftype.Tag,
+			Type:  ftype.Type,
+		}
+		if info.Alt != "" {
+			info.Key = info.Alt
+		}
+		info.Key = strings.ToUpper(info.Key)
+		if ftype.Tag.Get("default") != "" {
+			v, err := typeConversion(ftype.Type.String(), ftype.Tag.Get("default"))
+			if err != nil {
+				return []structInfo{}, err
+			}
+			info.DefaultValue = v
+		}
+		infos = append(infos, info)
+	}
+	return infos, nil
+}
+
+func typeConversion(t, v string) (interface{}, error) {
+	switch t {
+	case "string":
+		return v, nil
+	case "int":
+		return strconv.ParseInt(v, 10, 0)
+	case "int8":
+		return strconv.ParseInt(v, 10, 8)
+	case "int16":
+		return strconv.ParseInt(v, 10, 16)
+	case "int32":
+		return strconv.ParseInt(v, 10, 32)
+	case "int64":
+		return strconv.ParseInt(v, 10, 64)
+	case "uint":
+		return strconv.ParseUint(v, 10, 0)
+	case "uint16":
+		return strconv.ParseUint(v, 10, 16)
+	case "uint32":
+		return strconv.ParseUint(v, 10, 32)
+	case "uint64":
+		return strconv.ParseUint(v, 10, 64)
+	case "float32":
+		return strconv.ParseFloat(v, 32)
+	case "float64":
+		return strconv.ParseFloat(v, 64)
+	case "complex64":
+		return strconv.ParseComplex(v, 64)
+	case "complex128":
+		return strconv.ParseComplex(v, 128)
+	case "bool":
+		return strconv.ParseBool(v)
+	}
+	return nil, fmt.Errorf("Unable to identify type.")
+}
+
+// getEnvString returns string from environment variable
+func getEnvString(env, def string) (val string) { //nolint:deadcode
+	val = os.Getenv(env)
+
+	if val == "" {
+		return def
+	}
+
+	return
+}
+
+// getEnvInt returns int from environment variable
+func getEnvInt(env string, def int) (ret int) {
+	val := os.Getenv(env)
+
+	if val == "" {
+		return def
+	}
+
+	ret, err := strconv.Atoi(val)
+	if err != nil {
+		log.Fatalf("[ERROR] Environment variable is not numeric: %v\n", env)
+	}
+
+	return
+}
+
+// getEnvBool returns boolean from environment variable
+func getEnvBool(env string, def bool) bool {
+	var (
+		err    error
+		retVal bool
+		val    = os.Getenv(env)
+	)
+
+	if len(val) == 0 {
+		return def
+	} else {
+		retVal, err = strconv.ParseBool(val)
+		if err != nil {
+			log.Fatalf("[ERROR] Environment variable is not boolean: %v\n", env)
+		}
+	}
+
+	return retVal
+}
+
+// Init initializes the application configuration by reading default values from the struct's tags
+// and environment variables. Tags processed by this process are as follows:
+// `ignored:"true" env:"ENVIRONMENT_VARIABLE" default:"default value"`
+func initialize() *config {
+	cfg := defaultConfig()
+	var hosts hostStruct
+
+	cfgInfo, err := getStructInfo(cfg)
+	if err != nil {
+		log.Fatalf("[FATAL] %v", err)
+	}
+
+	for _, info := range cfgInfo {
+		switch info.Type.String() {
+		case "string":
+			var dv string
+
+			if info.DefaultValue != nil {
+				dv = info.DefaultValue.(string)
+			}
+			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*string)
+			flag.StringVar(p, info.Name, getEnvString(info.Name, dv), "("+info.Key+")")
+		case "bool":
+			var dv bool
+
+			if info.DefaultValue != nil {
+				dv = info.DefaultValue.(bool)
+			}
+			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*bool)
+			flag.BoolVar(p, info.Name, getEnvBool(info.Name, dv), "("+info.Key+")")
+		case "int":
+			var dv int
+
+			if info.DefaultValue != nil {
+				dv = int(info.DefaultValue.(int64))
+			}
+			p := reflect.ValueOf(cfg).Elem().FieldByName(info.Name).Addr().Interface().(*int)
+			flag.IntVar(p, info.Name, getEnvInt(info.Name, dv), "("+info.Key+")")
+		}
+	}
+
+	flag.Var(&hosts, "host", "Host to monitor")
+	flag.Parse()
+	cfg.Hosts = hosts
+
+	// set logging level
+	cfg.setLogLevel()
+
+	// timezone & format configuration
+	cfg.TZoneUTC, _ = time.LoadLocation("UTC")
+	if err != nil {
+		log.Fatalf("[ERROR] Unable to parse timezone string. Please use one of the timezone database values listed here: %s", "https://en.wikipedia.org/wiki/List_of_tz_database_time_zones")
+	}
+	cfg.TZoneLocal, err = time.LoadLocation(cfg.TimeZoneLocal)
+	if err != nil {
+		log.Fatalf("[ERROR] Unable to parse timezone string. Please use one of the timezone database values listed here: %s", "https://en.wikipedia.org/wiki/List_of_tz_database_time_zones")
+	}
+	time.Now().Format(cfg.TimeFormat)
+
+	prometheus.MustRegister(cfg.Prometheus.CurrentMa, cfg.Prometheus.VoltageMv, cfg.Prometheus.PowerMw)
+
+	// print running config
+	cfg.printRunningConfig(cfgInfo)
+
+	log.Println("[INFO] initialization complete")
+	return cfg
+}
--- a/cmd/export/httpServer.go
+++ b/cmd/export/httpServer.go
@@ -0,0 +1,72 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"time"
+
+	"net/http"
+
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+func httpAccessLog(req *http.Request) {
+	log.Printf("[TRACE] %s - %s - %s\n", req.Method, req.RemoteAddr, req.RequestURI)
+}
+
+func crossSiteOrigin(w http.ResponseWriter) {
+	w.Header().Add("Access-Control-Allow-Origin", "*")
+	w.Header().Add("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
+}
+
+func (config *config) httpServer() {
+	path := http.NewServeMux()
+
+	connection := &http.Server{
+		Addr:         fmt.Sprintf("%s:%d", config.WebSrvIP, config.WebSrvPort),
+		Handler:      path,
+		ReadTimeout:  time.Duration(config.WebSrvReadTimeout) * time.Second,
+		WriteTimeout: time.Duration(config.WebSrvWriteTimeout) * time.Second,
+		IdleTimeout:  time.Duration(config.WebSrvIdleTimeout) * time.Second,
+	}
+
+	// metrics
+	path.HandleFunc("/metrics", func(w http.ResponseWriter, r *http.Request) {
+		httpAccessLog(r)
+		crossSiteOrigin(w)
+		promhttp.Handler().ServeHTTP(w, r)
+	})
+	// healthcheck
+	path.HandleFunc("/healthcheck", webHealthCheck)
+	// root
+	path.HandleFunc("/", webRoot)
+
+	if err := connection.ListenAndServe(); err != nil {
+		log.Fatalf("[ERROR] %s\n", err)
+	}
+}
+
+func webRoot(w http.ResponseWriter, r *http.Request) {
+	httpAccessLog(r)
+	crossSiteOrigin(w)
+
+	if strings.ToLower(r.Method) == "get" {
+		tmpltWebRoot(w)
+	} else {
+		log.Printf("[DEBUG] Request to '/' was made using the wrong method: expected %s, got %s\n", "GET", strings.ToUpper(r.Method))
+		tmpltError(w, http.StatusBadRequest, "Invalid http method.")
+	}
+}
+
+func webHealthCheck(w http.ResponseWriter, r *http.Request) {
+	httpAccessLog(r)
+	crossSiteOrigin(w)
+
+	if strings.ToLower(r.Method) == "get" {
+		tmpltHealthCheck(w)
+	} else {
+		log.Printf("[DEBUG] Request to '/healthcheck' was made using the wrong method: expected %s, got %s\n", "GET", strings.ToUpper(r.Method))
+		tmpltError(w, http.StatusBadRequest, "Invalid http method.")
+	}
+}
--- a/cmd/export/httpTemplates.go
+++ b/cmd/export/httpTemplates.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+	"log"
+
+	"encoding/json"
+	"net/http"
+)
+
+func tmpltError(w http.ResponseWriter, s int, m string) {
+	var (
+		output []byte
+		o      = struct {
+			Error    bool   `json:"error" yaml:"error"`
+			ErrorMsg string `json:"errorMessage" yaml:"errorMessage"`
+		}{
+			Error:    true,
+			ErrorMsg: m,
+		}
+		err error
+	)
+
+	w.Header().Add("Content-Type", "application/json")
+
+	output, err = json.MarshalIndent(o, "", "  ")
+	if err != nil {
+		log.Printf("[TRACE] Unable to marshal error message: %v.", err)
+	}
+	w.WriteHeader(s)
+	w.Write(output) //nolint:errcheck
+}
+
+func tmpltWebRoot(w http.ResponseWriter) {
+	o := struct {
+		Application string `json:"application" yaml:"application"`
+		Description string `json:"description" yaml:"description"`
+		Version     string `json:"version" yaml:"version"`
+	}{
+		Application: "TP-Link Web API",
+		Description: "API for automated calls to TP-Link devices",
+		Version:     "v1.0.0",
+	}
+	w.Header().Add("Content-Type", "application/json")
+
+	output, err := json.MarshalIndent(o, "", "  ")
+	if err != nil {
+		log.Printf("[TRACE] Unable to marshal error message: %v.", err)
+	}
+	w.Write(output) //nolint:errcheck
+}
+
+func tmpltHealthCheck(w http.ResponseWriter) {
+	o := struct {
+		WebServer bool   `json:"webServerActive" yaml:"webServerActive"`
+		Status    string `json:"status" yaml:"status"`
+	}{
+		WebServer: true,
+		Status:    "healthy",
+	}
+
+	output, err := json.MarshalIndent(o, "", "  ")
+	if err != nil {
+		log.Printf("[TRACE] Unable to marshal status message: %v.", err)
+	}
+
+	w.Header().Add("Content-Type", "application/json")
+	w.Write(output) //nolint:errcheck
+}
--- a/cmd/export/main.go
+++ b/cmd/export/main.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"log"
+	"os"
+	"syscall"
+
+	"os/signal"
+)
+
+func forever() {
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+
+	sig := <-c
+	log.Printf("[INFO] shutting down, detected signal: %s", sig)
+}
+
+func main() {
+	cfg := initialize()
+
+	defer func() {
+		log.Println("[DEBUG] shutdown sequence complete")
+	}()
+
+	go cfg.httpServer()
+
+	go cfg.gatherMetrics()
+
+	forever()
+}
--- a/cmd/export/readMetrics.go
+++ b/cmd/export/readMetrics.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"log"
+	"time"
+
+	"tplink/internal/tplink"
+
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+func (cfg *config) gatherMetrics() {
+	for {
+		for _, host := range cfg.Hosts {
+			d := tplink.Tplink{
+				Host: host,
+			}
+			m, err := d.GetMeterInto()
+			if err != nil {
+				log.Printf("[WARNING] Unable to read from device: %s: %v", host, err)
+				continue
+			}
+			cfg.Prometheus.CurrentMa.With(prometheus.Labels{"device": host}).Set(float64(m.Emeter.GetRealtime.CurrentMa))
+			cfg.Prometheus.VoltageMv.With(prometheus.Labels{"device": host}).Set(float64(m.Emeter.GetRealtime.VoltageMv))
+			cfg.Prometheus.PowerMw.With(prometheus.Labels{"device": host}).Set(float64(m.Emeter.GetRealtime.PowerMw))
+		}
+		time.Sleep(time.Duration(time.Second * 15))
+	}
+}