Read config from YAML file

config.go

@@ -0,0 +1,162 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"git.sr.ht/~michalr/go-satel"
+	"gopkg.in/yaml.v3"
+)
+
+const (
+	ConfigFilePath = "hswro-alarm-bot.yml"
+)
+
+type OwnDuration struct {
+	duration time.Duration
+}
+
+type SatelChangeType struct {
+	changeType satel.ChangeType
+}
+
+type AppConfig struct {
+	SatelAddr          string            `yaml:"satel-addr"`
+	ChatIds            []int64           `yaml:"tg-chat-ids"`
+	AllowedTypes       []SatelChangeType `yaml:"allowed-types"`
+	AllowedIndexes     []int             `yaml:"allowed-indexes"`
+	PoolInterval       OwnDuration       `yaml:"pool-interval"`
+	ArmCallbackUrls    []string          `yaml:"arm-callback-urls"`
+	DisarmCallbackUrls []string          `yaml:"disarm-callback-urls"`
+	AlarmCallbackUrls  []string          `yaml:"alarm-callback-urls"`
+}
+
+func (m *SatelChangeType) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var inputStr string
+	err := unmarshal(&inputStr)
+	if err != nil {
+		return err
+	}
+	ct, err := StringToSatelChangeType(inputStr)
+	if err != nil {
+		return err
+	}
+	*m = SatelChangeType{ct}
+	return nil
+}
+
+func (m *OwnDuration) UnmarshalYAML(unmarshal func(interface{}) error) error {
+	var inputStr string
+	err := unmarshal(&inputStr)
+	if err != nil {
+		return err
+	}
+	duration, err := time.ParseDuration(inputStr)
+	if err != nil {
+		return err
+	}
+	*m = OwnDuration{duration}
+	return nil
+}
+
+func (self SatelChangeType) GetChangeType() satel.ChangeType { return self.changeType }
+func (self OwnDuration) GetDuration() time.Duration          { return self.duration }
+
+func loadConfigFromFile(filePath string, logger *log.Logger) AppConfig {
+	f, err := os.ReadFile(filePath)
+	if err != nil {
+		logger.Print("Error opening config file: ", err, ". Trying to continue without it")
+		return AppConfig{}
+	}
+	return parseConfigFromFile(f, logger)
+}
+
+func parseConfigFromFile(contents []byte, logger *log.Logger) AppConfig {
+	var config AppConfig
+	err := yaml.Unmarshal(contents, &config)
+	if err != nil {
+		logger.Print("Error while parsing config file: ", err, ". Trying to continue without it")
+		return AppConfig{}
+	}
+	return config
+}
+
+func getCmdLineParams(config *AppConfig, logger *log.Logger) {
+	satelApiAddr := flag.String("satel-addr", "", "Address that should be used to connect to the SATEL device")
+	satelApiPort := flag.String("satel-port", "7094", "Port that should be used to connect to the SATEL device")
+	chatIdRaw := flag.String("tg-chat-id", "", "Telegram Chat ID where to send updates. Use \",\" to specify multiple IDs.")
+	allowedTypesRaw := flag.String("allowed-types", "", "Satel change types that are allowed. All other types will be discarded. By default all are allowed. Use \",\" to specify multiple types.")
+	allowedIndexesRaw := flag.String("allowed-indexes", "", "Satel indexes (zones?) that are allowed. All other indexes will be discarded. By default all are allowed. Use \",\" to specify multiple indexes.")
+	satelPoolInterval := flag.Duration("pool-interval", 5*time.Second, "How often should the SATEL device be pooled for changes? Default: 5 seconds.")
+	flag.Parse()
+
+	if len(*satelApiAddr) == 0 || len(*satelApiPort) == 0 || len(*chatIdRaw) == 0 {
+		logger.Fatal("Use --satel-addr=ADDR, --satel-port=PORT and --tg-chat-id=CHAT_ID command line flags to continue.")
+	}
+	chatIdsStrings := strings.Split(*chatIdRaw, ",")
+	var chatIds []int64
+	for _, chatIdStr := range chatIdsStrings {
+		chatId, err := strconv.ParseInt(chatIdStr, 10, 64)
+		if err != nil {
+			logger.Fatalf("Tried to use a non-int value for one of tg_chatIds: %s. That's bad.", chatIdStr)
+		}
+		chatIds = append(chatIds, chatId)
+	}
+	allowedTypesStrings := strings.Split(*allowedTypesRaw, ",")
+	var allowedTypes []SatelChangeType
+	for _, allowedTypeStr := range allowedTypesStrings {
+		if len(allowedTypeStr) == 0 {
+			continue
+		}
+		allowedType, err := StringToSatelChangeType(allowedTypeStr)
+		if err != nil {
+			logger.Fatalf("Error trying to understand an allowed type: %s.", err)
+		}
+		allowedTypes = append(allowedTypes, SatelChangeType{allowedType})
+	}
+	allowedIndexesStrings := strings.Split(*allowedIndexesRaw, ",")
+	var allowedIndexes []int
+	for _, allowedIndexStr := range allowedIndexesStrings {
+		if len(allowedIndexStr) == 0 {
+			continue
+		}
+		allowedIndex, err := strconv.ParseInt(allowedIndexStr, 10, 0)
+		if err != nil {
+			logger.Fatalf("Tried to use a non-int value for one of allowed indexes: %s. That's bad.", allowedIndexStr)
+		}
+		allowedIndexes = append(allowedIndexes, int(allowedIndex))
+	}
+
+	satelAddr := fmt.Sprintf("%s:%s", *satelApiAddr, *satelApiPort)
+
+	config.SatelAddr = satelAddr
+	config.ChatIds = chatIds
+	config.AllowedTypes = allowedTypes
+	config.AllowedIndexes = allowedIndexes
+	config.PoolInterval = OwnDuration{*satelPoolInterval}
+}
+
+func MakeConfig(logger *log.Logger) AppConfig {
+	config := loadConfigFromFile(ConfigFilePath, logger)
+	config.ArmCallbackUrls = []string{}
+	config.DisarmCallbackUrls = []string{}
+	config.AlarmCallbackUrls = []string{}
+
+	if len(os.Getenv("NOTIFY_URL_ARM")) != 0 {
+		config.ArmCallbackUrls = append(config.ArmCallbackUrls, os.Getenv("NOTIFY_URL_ARM"))
+	}
+	if len(os.Getenv("NOTIFY_URL_DISARM")) != 0 {
+		config.DisarmCallbackUrls = append(config.DisarmCallbackUrls, os.Getenv("NOTIFY_URL_DISARM"))
+	}
+	if len(os.Getenv("ALARM_URL_ARM")) != 0 {
+		config.AlarmCallbackUrls = append(config.AlarmCallbackUrls, os.Getenv("ALARM_URL_ARM"))
+	}
+
+	getCmdLineParams(&config, logger)
+	return config
+}

config_test.go

@@ -0,0 +1,50 @@
+package main
+
+import (
+	"log"
+	"os"
+	"testing"
+	"time"
+
+	"git.sr.ht/~michalr/go-satel"
+	"github.com/stretchr/testify/assert"
+)
+
+const data = `
+satel-addr: "test satel address"
+tg-chat-ids:
+ - 1234
+ - 5678
+ - 9876
+allowed-types:
+ - "zone-isolate"
+ - "zone-alarm"
+allowed-indexes:
+ - 5678
+ - 1337
+pool-interval: 5m
+arm-callback-urls:
+ - "test arm callback url"
+ - "second test arm callback url"
+disarm-callback-urls:
+ - "test disarm callback url"
+ - "second test disarm callback url"
+alarm-callback-urls:
+ - "test alarm callback url"
+ - "second test alarm callback url"
+`
+
+func TestParseYamlConfig(t *testing.T) {
+	a := assert.New(t)
+
+	actualConfig := parseConfigFromFile([]byte(data), log.New(os.Stderr, "", log.Ltime))
+
+	a.Equal("test satel address", actualConfig.SatelAddr)
+	a.ElementsMatch([]int64{1234, 5678, 9876}, actualConfig.ChatIds)
+	a.ElementsMatch([]int{5678, 1337}, actualConfig.AllowedIndexes)
+	a.ElementsMatch([]SatelChangeType{{satel.ZoneIsolate}, {satel.ZoneAlarm}}, actualConfig.AllowedTypes)
+	a.Equal(5*time.Minute, actualConfig.PoolInterval.GetDuration())
+	a.ElementsMatch([]string{"test arm callback url", "second test arm callback url"}, actualConfig.ArmCallbackUrls)
+	a.ElementsMatch([]string{"test disarm callback url", "second test disarm callback url"}, actualConfig.DisarmCallbackUrls)
+	a.ElementsMatch([]string{"test alarm callback url", "second test alarm callback url"}, actualConfig.AlarmCallbackUrls)
+}

filters.go

@@ -7,9 +7,9 @@ import (
 	"git.sr.ht/~michalr/go-satel"
 )
 
-func isBasicEventElementOkay(basicEventElement satel.BasicEventElement, allowedTypes []satel.ChangeType, allowedIndexes []int) bool {
+func isBasicEventElementOkay(basicEventElement satel.BasicEventElement, allowedTypes []SatelChangeType, allowedIndexes []int) bool {
 	for _, allowedType := range allowedTypes {
-		if allowedType == basicEventElement.Type {
+		if allowedType.GetChangeType() == basicEventElement.Type {
 			return true
 		}
 	}
@@ -21,7 +21,7 @@ func isBasicEventElementOkay(basicEventElement satel.BasicEventElement, allowedT
 	return false
 }
 
-func FilterByTypeOrIndex(ev <-chan satel.Event, wg *sync.WaitGroup, allowedTypes []satel.ChangeType, allowedIndexes []int) <-chan satel.Event {
+func FilterByTypeOrIndex(ev <-chan satel.Event, wg *sync.WaitGroup, allowedTypes []SatelChangeType, allowedIndexes []int) <-chan satel.Event {
 	returnChan := make(chan satel.Event)
 
 	if (len(allowedTypes) == 0) && (len(allowedIndexes) == 0) {

filters_test.go

@@ -18,7 +18,7 @@ func TestSatelEventTypeFiltering(t *testing.T) {
 
 	go func() {
 		wg.Add(1)
-		for e := range FilterByTypeOrIndex(testEvents, &wg, []satel.ChangeType{satel.ArmedPartition, satel.PartitionFireAlarm}, []int{}) {
+		for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{{satel.ArmedPartition}, {satel.PartitionFireAlarm}}, []int{}) {
 			receivedEvents = append(receivedEvents, e)
 		}
 		wg.Done()
@@ -46,7 +46,7 @@ func TestSatelEventTypeFiltering_NoAllowedEventTypesMeansAllAreAllowed(t *testin
 
 	go func() {
 		wg.Add(1)
-		for e := range FilterByTypeOrIndex(testEvents, &wg, []satel.ChangeType{}, []int{}) {
+		for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{}, []int{}) {
 			receivedEvents = append(receivedEvents, e)
 		}
 		wg.Done()
@@ -72,7 +72,7 @@ func TestSatelIndexFiltering(t *testing.T) {
 
 	go func() {
 		wg.Add(1)
-		for e := range FilterByTypeOrIndex(testEvents, &wg, []satel.ChangeType{}, []int{1, 3}) {
+		for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{}, []int{1, 3}) {
 			receivedEvents = append(receivedEvents, e)
 		}
 		wg.Done()
@@ -101,7 +101,7 @@ func TestSatelIndexFiltering_NoAllowedEventTypesMeansAllAreAllowed(t *testing.T)
 
 	go func() {
 		wg.Add(1)
-		for e := range FilterByTypeOrIndex(testEvents, &wg, []satel.ChangeType{}, []int{}) {
+		for e := range FilterByTypeOrIndex(testEvents, &wg, []SatelChangeType{}, []int{}) {
 			receivedEvents = append(receivedEvents, e)
 		}
 		wg.Done()

main.go

@@ -1,16 +1,13 @@
 package main
 
 import (
-	"flag"
-	"fmt"
 	"html/template"
 	"log"
 	"net"
 	"os"
 	"path/filepath"
-	"strconv"
-	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"git.sr.ht/~michalr/go-satel"
@@ -19,6 +16,7 @@ import (
 
 const (
 	PersistenceFilename = "hs_wro_last_seen.bin"
+	retryDelaySec       = 25
 )
 
 type RealSleeper struct {
@@ -32,56 +30,6 @@ func (self RealSleeper) Sleep(ch chan<- interface{}) {
 	}()
 }
 
-func getCmdLineParams(logger *log.Logger) (string, []int64, []satel.ChangeType, []int, time.Duration) {
-	satelApiAddr := flag.String("satel-addr", "", "Address that should be used to connect to the SATEL device")
-	satelApiPort := flag.String("satel-port", "7094", "Port that should be used to connect to the SATEL device")
-	chatIdRaw := flag.String("tg-chat-id", "", "Telegram Chat ID where to send updates. Use \",\" to specify multiple IDs.")
-	allowedTypesRaw := flag.String("allowed-types", "", "Satel change types that are allowed. All other types will be discarded. By default all are allowed. Use \",\" to specify multiple types.")
-	allowedIndexesRaw := flag.String("allowed-indexes", "", "Satel indexes (zones?) that are allowed. All other indexes will be discarded. By default all are allowed. Use \",\" to specify multiple indexes.")
-	satelPoolInterval := flag.Duration("pool-interval", 5*time.Second, "How often should the SATEL device be pooled for changes? Default: 5 seconds.")
-	flag.Parse()
-
-	if len(*satelApiAddr) == 0 || len(*satelApiPort) == 0 || len(*chatIdRaw) == 0 {
-		logger.Fatal("Use --satel-addr=ADDR, --satel-port=PORT and --tg-chat-id=CHAT_ID command line flags to continue.")
-	}
-	chatIdsStrings := strings.Split(*chatIdRaw, ",")
-	var chatIds []int64
-	for _, chatIdStr := range chatIdsStrings {
-		chatId, err := strconv.ParseInt(chatIdStr, 10, 64)
-		if err != nil {
-			logger.Fatalf("Tried to use a non-int value for one of tg_chatIds: %s. That's bad.", chatIdStr)
-		}
-		chatIds = append(chatIds, chatId)
-	}
-	allowedTypesStrings := strings.Split(*allowedTypesRaw, ",")
-	var allowedTypes []satel.ChangeType
-	for _, allowedTypeStr := range allowedTypesStrings {
-		if len(allowedTypeStr) == 0 {
-			continue
-		}
-		allowedType, err := StringToSatelChangeType(allowedTypeStr)
-		if err != nil {
-			logger.Fatalf("Error trying to understand an allowed type: %s.", err)
-		}
-		allowedTypes = append(allowedTypes, allowedType)
-	}
-	allowedIndexesStrings := strings.Split(*allowedIndexesRaw, ",")
-	var allowedIndexes []int
-	for _, allowedIndexStr := range allowedIndexesStrings {
-		if len(allowedIndexStr) == 0 {
-			continue
-		}
-		allowedIndex, err := strconv.ParseInt(allowedIndexStr, 10, 0)
-		if err != nil {
-			logger.Fatalf("Tried to use a non-int value for one of allowed indexes: %s. That's bad.", allowedIndexStr)
-		}
-		allowedIndexes = append(allowedIndexes, int(allowedIndex))
-	}
-
-	satelAddr := fmt.Sprintf("%s:%s", *satelApiAddr, *satelApiPort)
-	return satelAddr, chatIds, allowedTypes, allowedIndexes, *satelPoolInterval
-}
-
 func makeSatel(satelAddr string, poolInterval time.Duration) *satel.Satel {
 	satelConn, err := net.Dial("tcp", satelAddr)
 	if err != nil {
@@ -100,16 +48,18 @@ func getPersistenceFilePath() string {
 
 func main() {
 	var (
-		wg       sync.WaitGroup
-		tgEvents = make(chan GenericMessage, 5)
-		logger   = log.New(os.Stderr, "Main", log.Lmicroseconds)
-		sleeper  = RealSleeper{time.Second * 60}
+		wg            sync.WaitGroup
+		tgEvents      = make(chan GenericMessage, 5)
+		logger        = log.New(os.Stderr, "Main", log.Lmicroseconds)
+		sleeper       = RealSleeper{time.Second * 60}
+		stopRequested = atomic.Bool{}
 	)
 
-	satelAddr, chatIds, allowedTypes, allowedIndexes, poolInterval := getCmdLineParams(logger)
+	stopRequested.Store(false)
+	config := MakeConfig(logger)
 
-	s := makeSatel(satelAddr, poolInterval)
-	logger.Printf("Connected to Satel: %s", satelAddr)
+	s := makeSatel(config.SatelAddr, config.PoolInterval.GetDuration())
+	logger.Printf("Connected to Satel: %s", config.SatelAddr)
 
 	bot, err := tgbotapi.NewBotAPI(os.Getenv("TELEGRAM_APITOKEN"))
 	if err != nil {
@@ -117,25 +67,31 @@ func main() {
 	}
 	logger.Print("Created Telegram Bot API client")
 
-	tgSender := TgSender{bot, s, log.New(os.Stderr, "TgFormatter", log.Lmicroseconds), chatIds}
+	tgSender := TgSender{bot, s, log.New(os.Stderr, "TgFormatter", log.Lmicroseconds), config.ChatIds}
 
 	tpl := template.Must(template.New("TelegramMessage").Parse(TelegramMessageTemplate))
 
 	dataStore := MakeDataStore(log.New(os.Stderr, "DataStore", log.Lmicroseconds), getPersistenceFilePath())
 
 	Consume(
-		SendToTg(Throttle(NotifyViaHTTP(tgEvents, &wg, log.New(os.Stderr, "HTTPNotify", log.Lmicroseconds)),
+		SendToTg(Throttle(NotifyViaHTTP(tgEvents, config, &wg, log.New(os.Stderr, "HTTPNotify", log.Lmicroseconds)),
 			&wg, sleeper, log.New(os.Stderr, "MessageThrottle", log.Lmicroseconds)),
 			tgSender, &wg, log.New(os.Stderr, "SendToTg", log.Lmicroseconds), tpl),
 	)
 
-	go CloseSatelOnCtrlC(s)
+	go CloseSatelOnCtrlC(s, &stopRequested)
 
-	for e := range FilterByTypeOrIndex(
-		FilterByLastSeen(s.Events, &wg, &dataStore, log.New(os.Stderr, "FilterByLastSeen", log.Lmicroseconds)),
-		&wg, allowedTypes, allowedIndexes) {
-		logger.Print("Received change from SATEL: ", e)
-		tgEvents <- GenericMessage{e.BasicEvents}
+	for stopRequested.Load() == false {
+		for e := range FilterByTypeOrIndex(
+			FilterByLastSeen(s.Events, &wg, &dataStore, log.New(os.Stderr, "FilterByLastSeen", log.Lmicroseconds)),
+			&wg, config.AllowedTypes, config.AllowedIndexes) {
+			logger.Print("Received change from SATEL: ", e)
+			tgEvents <- GenericMessage{e.BasicEvents}
+		}
+		if stopRequested.Load() == false {
+			logger.Printf("Waiting %d seconds before trying again", retryDelaySec)
+			time.Sleep(retryDelaySec * time.Second)
+		}
 	}
 
 	close(tgEvents)

satel_utils.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
+	"sync/atomic"
 
 	"git.sr.ht/~michalr/go-satel"
 )
@@ -93,10 +94,11 @@ var SATEL_STRING_TO_CHANGE_TYPE = map[string]satel.ChangeType{
 	"zone-isolate":                    satel.ZoneIsolate,
 }
 
-func CloseSatelOnCtrlC(s *satel.Satel) {
+func CloseSatelOnCtrlC(s *satel.Satel, stopRequested *atomic.Bool) {
 	exitSignal := make(chan os.Signal, 1)
 	signal.Notify(exitSignal, os.Interrupt)
 	<-exitSignal
+	stopRequested.Store(true)
 	s.Close()
 }
 

sender_worker.go

@@ -4,7 +4,6 @@ import (
 	"html/template"
 	"log"
 	"net/http"
-	"os"
 	"sync"
 
 	"git.sr.ht/~michalr/go-satel"
@@ -52,6 +51,7 @@ func SendToTg(events <-chan GenericMessage, s Sender, wg *sync.WaitGroup, logger
 func doHttpNotification(url string, logger *log.Logger, wg *sync.WaitGroup) {
 	wg.Add(1)
 	defer wg.Done()
+
 	if len(url) == 0 {
 		return
 	}
@@ -65,43 +65,41 @@ func doHttpNotification(url string, logger *log.Logger, wg *sync.WaitGroup) {
 	logger.Print("Notified via HTTP with result ", res.StatusCode)
 }
 
-func NotifyViaHTTP(events <-chan GenericMessage, wg *sync.WaitGroup, logger *log.Logger) <-chan GenericMessage {
+func notifyAllHttp(urls []string, logger *log.Logger, wg *sync.WaitGroup) {
+	for _, uri := range urls {
+		go doHttpNotification(uri, logger, wg)
+	}
+}
+
+func NotifyViaHTTP(events <-chan GenericMessage, config AppConfig, wg *sync.WaitGroup, logger *log.Logger) <-chan GenericMessage {
 	returnEvents := make(chan GenericMessage)
-	armCallbackUrl := os.Getenv("NOTIFY_URL_ARM")
-	disarmCallbackUrl := os.Getenv("NOTIFY_URL_DISARM")
-	alarmCallbackUrl := os.Getenv("ALARM_URL_ARM")
-	armDisarmCallbackEnabled := (len(armCallbackUrl) != 0) && (len(disarmCallbackUrl) != 0)
-	alarmCallbackEnabled := (len(alarmCallbackUrl) != 0)
 
 	go func() {
 		wg.Add(1)
 		defer wg.Done()
 		for e := range events {
 			returnEvents <- e
-			if armDisarmCallbackEnabled {
-			inner_arm:
-				for _, basicElement := range e.Messages {
-					if (basicElement.Index == NotificationPartitionIndex) && (basicElement.Type == satel.ArmedPartition) {
-						if basicElement.Value == ArmedPartition_Armed {
-							go doHttpNotification(armCallbackUrl, logger, wg)
-						} else {
-							go doHttpNotification(disarmCallbackUrl, logger, wg)
-						}
-						break inner_arm
-					}
-				}
-			}
-			if alarmCallbackEnabled {
-			inner_alarm:
-				for _, basicElement := range e.Messages {
-					if basicElement.Type == satel.PartitionAlarm {
-						if basicElement.Value == PartitionAlarm_Alarm {
-							go doHttpNotification(alarmCallbackUrl, logger, wg)
-							break inner_alarm
-						}
+		inner_arm:
+			for _, basicElement := range e.Messages {
+				if (basicElement.Index == NotificationPartitionIndex) && (basicElement.Type == satel.ArmedPartition) {
+					if basicElement.Value == ArmedPartition_Armed {
+						notifyAllHttp(config.ArmCallbackUrls, logger, wg)
+					} else {
+						notifyAllHttp(config.DisarmCallbackUrls, logger, wg)
+					}
+					break inner_arm
+				}
+			}
+		inner_alarm:
+			for _, basicElement := range e.Messages {
+				if basicElement.Type == satel.PartitionAlarm {
+					if basicElement.Value == PartitionAlarm_Alarm {
+						notifyAllHttp(config.AlarmCallbackUrls, logger, wg)
+						break inner_alarm
 					}
 				}
 			}
+
 		}
 		close(returnEvents)
 	}()