mirror of
https://github.com/Luzifer/tasmota-config.git
synced 2024-12-22 18:51:21 +00:00
178 lines
5.1 KiB
Go
178 lines
5.1 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
mqtt "github.com/eclipse/paho.mqtt.golang"
|
|
"github.com/pkg/errors"
|
|
log "github.com/sirupsen/logrus"
|
|
|
|
"github.com/Luzifer/rconfig/v2"
|
|
)
|
|
|
|
var (
|
|
cfg = struct {
|
|
Config string `flag:"config,c" default:"config.yaml" description:"Configuration file with settings"`
|
|
Device string `flag:"device,d" default:"" description:"Limit execution to specific device by name"`
|
|
DryRun bool `flag:"dry-run,n" default:"false" description:"Do not execute write actions, just print changes"`
|
|
LogLevel string `flag:"log-level" default:"info" description:"Log level (debug, info, warn, error, fatal)"`
|
|
MQTTBroker string `flag:"mqtt-broker" default:"tcp://localhost:1883" description:"MQTT Broker to connect to"`
|
|
MQTTCommandTimeout time.Duration `flag:"mqtt-command-timeout" default:"2s" description:"How long to wait for commands to succeed"`
|
|
MQTTPassword string `flag:"mqtt-password" default:"" description:"Credentials for MQTT-Broker"`
|
|
MQTTUsername string `flag:"mqtt-username" default:"" description:"Credentials for MQTT-Broker"`
|
|
VersionAndExit bool `flag:"version" default:"false" description:"Prints current version and exits"`
|
|
}{}
|
|
|
|
version = "dev"
|
|
)
|
|
|
|
func init() {
|
|
rconfig.AutoEnv(true)
|
|
if err := rconfig.ParseAndValidate(&cfg); err != nil {
|
|
log.Fatalf("Unable to parse commandline options: %s", err)
|
|
}
|
|
|
|
if cfg.VersionAndExit {
|
|
fmt.Printf("tasmota-config %s\n", version)
|
|
os.Exit(0)
|
|
}
|
|
|
|
if l, err := log.ParseLevel(cfg.LogLevel); err != nil {
|
|
log.WithError(err).Fatal("Unable to parse log level")
|
|
} else {
|
|
log.SetLevel(l)
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
mqttConfig := mqtt.NewClientOptions().
|
|
AddBroker(cfg.MQTTBroker).
|
|
SetPassword(cfg.MQTTPassword).
|
|
SetUsername(cfg.MQTTUsername)
|
|
mqttClient := mqtt.NewClient(mqttConfig)
|
|
|
|
if err := checkToken(mqttClient.Connect()); err != nil {
|
|
log.WithError(err).Fatal("Unable to connect to broker due to error or timeout")
|
|
}
|
|
|
|
config, err := loadConfig(cfg.Config)
|
|
if err != nil {
|
|
log.WithError(err).Fatal("Unable to load config file")
|
|
}
|
|
|
|
for devName, devConfig := range config.Devices {
|
|
if cfg.Device != "" && devName != cfg.Device {
|
|
log.WithField("name", devName).Trace("Skipping device as requested")
|
|
continue
|
|
}
|
|
|
|
if err := processDevice(mqttClient, config, devName, devConfig); err != nil {
|
|
log.WithField("name", devName).WithError(err).Error("Unable to process device")
|
|
}
|
|
}
|
|
}
|
|
|
|
func processDevice(mqttClient mqtt.Client, config *configFile, devName string, devConfig deviceConfig) error {
|
|
log.WithField("name", devName).Info("Starting device config")
|
|
|
|
var (
|
|
responses = make(chan []byte, 30)
|
|
updates []string
|
|
)
|
|
defer close(responses)
|
|
|
|
if err := checkToken(mqttClient.Subscribe(
|
|
devConfig.constructTopic(config.StatPrefix, "RESULT"),
|
|
1,
|
|
func(c mqtt.Client, m mqtt.Message) { responses <- m.Payload() },
|
|
)); err != nil {
|
|
return errors.Wrap(err, "Unable to subscribe to topic due to error or timeout")
|
|
}
|
|
defer mqttClient.Unsubscribe(devConfig.constructTopic(config.StatPrefix, "RESULT"))
|
|
|
|
for setName, setValue := range mergeSettings(config.Settings, devConfig.Settings) {
|
|
if err := checkToken(mqttClient.Publish(
|
|
devConfig.constructTopic(config.CommandPrefix, setName),
|
|
1, false,
|
|
"",
|
|
)); err != nil {
|
|
return errors.Wrap(err, "Unable to send request command")
|
|
}
|
|
|
|
resp, err := extractSettingValue(setName, responses)
|
|
if err != nil {
|
|
return errors.Wrap(err, "Unable to extract settings value")
|
|
}
|
|
|
|
if resp == setValue {
|
|
log.WithFields(log.Fields{
|
|
"name": devName,
|
|
"expected": setValue,
|
|
"setting": setName,
|
|
}).Debug("Value is fine")
|
|
continue
|
|
}
|
|
|
|
log.WithFields(log.Fields{
|
|
"actual": fmt.Sprintf("%#v (%T)", resp, resp),
|
|
"expected": fmt.Sprintf("%#v (%T)", setValue, setValue),
|
|
"name": devName,
|
|
"setting": setName,
|
|
}).Warn("Value needs adjustment")
|
|
|
|
updates = append(updates, fmt.Sprintf("%s %v", setName, setValue))
|
|
}
|
|
|
|
if len(updates) == 0 {
|
|
log.WithField("name", devName).Info("Device looks good, nothing to do")
|
|
return nil
|
|
}
|
|
|
|
if cfg.DryRun {
|
|
log.WithField("name", devName).Infof("Device needs %d updates but requested dry-run", len(updates))
|
|
return nil
|
|
}
|
|
|
|
log.WithField("name", devName).Infof("Requesting %d updates", len(updates))
|
|
|
|
log.WithField("name", devName).Tracef("Sending BackLog: %q", strings.Join(updates, "; "))
|
|
|
|
if err := checkToken(mqttClient.Publish(
|
|
devConfig.constructTopic(config.CommandPrefix, "BackLog"),
|
|
1, false,
|
|
strings.Join(updates, "; "),
|
|
)); err != nil {
|
|
return errors.Wrap(err, "Unable to send BackLog command")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func checkToken(tok mqtt.Token) error {
|
|
if !tok.WaitTimeout(cfg.MQTTCommandTimeout) {
|
|
return errors.New("Command timed out")
|
|
}
|
|
|
|
return errors.Wrap(tok.Error(), "Command errored")
|
|
}
|
|
|
|
func mergeSettings(global, local map[string]interface{}) map[string]interface{} {
|
|
var out = map[string]interface{}{}
|
|
|
|
if global != nil {
|
|
for k, v := range global {
|
|
out[k] = v
|
|
}
|
|
}
|
|
|
|
if local != nil {
|
|
for k, v := range local {
|
|
out[k] = v
|
|
}
|
|
}
|
|
|
|
return out
|
|
}
|