Little refactoring

README.md

@@ -4,7 +4,8 @@
 
 Warning: this is a proof of concept, don't rely on it
 
-I didn't even test it yet so no idea if it works
+It was very basically tested, and while it seems to work, approach it without any expectations.
+In other words - treat it as a toy, not as a tool that will save your life or valuables, because it probably won't.
 
 ## Usage
 
@@ -66,10 +67,41 @@ Supported types are:
  - `partition-with-violated-zones`
  - `zone-isolate`
 
-### Filtering events by index (I guess "zone", but I'm not sure)
+### Filtering events by index (which meaning depends on the change type)
 
 Use the `--allowed-indexes=1,2,3,...` command line parameter to set the list of allowed indexes (of course provide your own list instead of `1,2,3,...`). If that parameter is not provided, then all indexes are allowed; otherwise the notification is sent for all indexes.
 
+## example systemd unit
+
+```
+[Unit]
+Description=Satel Alarm Telegram Status Notifier
+Requires=network.target
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=/path/to/alarm_bot --satel-addr=192.168.13.37 --satel-port=7094 --tg-chat-id=1234,4567,9876
+Environment=TELEGRAM_APITOKEN=YOUR_API_TOKEN
+Environment=NOTIFY_URL_DISARM="http://localhost/disarmed"
+Environment=NOTIFY_URL_ARM="http://localhost/armed"
+DynamicUser=True
+RuntimeDirectory=hswro-alarm-bot
+StateDirectory=hswro-alarm-bot
+RestartSec=30
+Restart=on-failure
+
+CPUAccounting=true
+CPUQuota=5%
+MemoryAccounting=true
+MemoryHigh=25M
+MemoryMax=50M
+
+[Install]
+WantedBy=multi-user.target
+
+```
+
 ## Debugging
 
 Set the `OMIT_TG` environment variable to, well, omit sending anything over to Telegram and just see the logs instead.

filters.go

@@ -89,7 +89,7 @@ func FilterByLastSeen(ev <-chan satel.Event, wg *sync.WaitGroup, dataStore *Data
 
 func appendToGenericMessage(msg *GenericMessage, new *GenericMessage) *GenericMessage {
 	if msg == nil {
-		msg = &GenericMessage{new.ChatIds, make([]satel.BasicEventElement, 0)}
+		msg = &GenericMessage{make([]satel.BasicEventElement, 0)}
 	}
 
 throughNewMessages:

filters_test.go

@@ -251,12 +251,12 @@ func TestThrottle(t *testing.T) {
 		wg.Done()
 	}()
 
-	testEvents <- GenericMessage{TgChatId{123}, []satel.BasicEventElement{tplMessageTest1}}
+	testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest1}}
-	testEvents <- GenericMessage{TgChatId{123}, []satel.BasicEventElement{tplMessageTest2}}
+	testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest2}}
-	testEvents <- GenericMessage{TgChatId{123}, []satel.BasicEventElement{tplMessageTest3}}
+	testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest3}}
 	*mockSleeper.ch <- nil
 
-	testEvents <- GenericMessage{TgChatId{123}, []satel.BasicEventElement{tplMessageTest4}}
+	testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest4}}
 
 	close(testEvents)
 	wg.Wait()
@@ -272,7 +272,7 @@ func TestThrottle(t *testing.T) {
 }
 
 func makeMassiveEvent(element satel.BasicEventElement, numElements int) GenericMessage {
-	retval := GenericMessage{TgChatId{123}, make([]satel.BasicEventElement, 0)}
+	retval := GenericMessage{make([]satel.BasicEventElement, 0)}
 
 	for i := 0; i < numElements; i++ {
 		retval.Messages = append(retval.Messages, element)

main.go

@@ -21,33 +21,6 @@ const (
 	PersistenceFilename = "hs_wro_last_seen.bin"
 )
 
-type TgSender struct {
-	bot    *tgbotapi.BotAPI
-	s      SatelNameGetter
-	logger *log.Logger
-}
-
-func (self TgSender) Send(msg GenericMessage, tpl *template.Template) error {
-	chatIds := msg.ChatIds.GetTgIds()
-	if chatIds == nil {
-		return nil
-	}
-	message := msg.Format(tpl, self.s, self.logger)
-	for _, chatId := range *chatIds {
-		toSend := tgbotapi.NewMessage(chatId, message)
-		toSend.ParseMode = "HTML"
-		_, err := self.bot.Send(toSend)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func sendTgMessage(tgEvents chan GenericMessage, msg []satel.BasicEventElement, chatId int64) {
-	tgEvents <- GenericMessage{TgChatId{chatId}, msg}
-}
-
 type RealSleeper struct {
 	duration time.Duration
 }
@@ -144,7 +117,7 @@ func main() {
 	}
 	logger.Print("Created Telegram Bot API client")
 
-	tgSender := TgSender{bot, s, log.New(os.Stderr, "TgFormatter", log.Lmicroseconds)}
+	tgSender := TgSender{bot, s, log.New(os.Stderr, "TgFormatter", log.Lmicroseconds), chatIds}
 
 	tpl := template.Must(template.New("TelegramMessage").Parse(TelegramMessageTemplate))
 
@@ -162,9 +135,7 @@ func main() {
 		FilterByLastSeen(s.Events, &wg, &dataStore, log.New(os.Stderr, "FilterByLastSeen", log.Lmicroseconds)),
 		&wg, allowedTypes, allowedIndexes) {
 		logger.Print("Received change from SATEL: ", e)
-		for _, chatId := range chatIds {
+		tgEvents <- GenericMessage{e.BasicEvents}
-			sendTgMessage(tgEvents, e.BasicEvents, chatId)
-		}
 	}
 
 	close(tgEvents)

message_contents.go

@@ -32,12 +32,10 @@ type SatelMsgContent struct {
 }
 
 type GenericMessage struct {
-	ChatIds  ChatId
 	Messages []satel.BasicEventElement
 }
 
 type SatelMessage struct {
-	ChatIds  ChatId
 	Messages []SatelMsgContent
 }
 
@@ -66,7 +64,6 @@ func (self SatelMsgContent) GetName() string {
 func (self GenericMessage) Format(template *template.Template, s SatelNameGetter, logger *log.Logger) string {
 	b := strings.Builder{}
 	template.Execute(&b, SatelMessage{
-		self.ChatIds,
 		getSatelMessageContent(self.Messages, s, logger),
 	})
 	return b.String()

sender_worker.go

@@ -22,18 +22,6 @@ type Sleeper interface {
 	Sleep(ch chan<- interface{})
 }
 
-type ChatId interface {
-	GetTgIds() *[]int64
-}
-
-type TgChatId struct {
-	tgChatId int64
-}
-
-func (self TgChatId) GetTgIds() *[]int64 {
-	return &[]int64{self.tgChatId}
-}
-
 func Consume(events <-chan GenericMessage) {
 	go func() {
 		for range events {

telegram_utils.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"html/template"
+	"log"
+
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+)
+
+type TelegramBotSender interface {
+	Send(c tgbotapi.Chattable) (tgbotapi.Message, error)
+}
+
+type TgSender struct {
+	bot     TelegramBotSender
+	s       SatelNameGetter
+	logger  *log.Logger
+	chatIds []int64
+}
+
+func (self TgSender) Send(msg GenericMessage, tpl *template.Template) error {
+	if len(self.chatIds) == 0 {
+		return nil
+	}
+	message := msg.Format(tpl, self.s, self.logger)
+	for _, chatId := range self.chatIds {
+		toSend := tgbotapi.NewMessage(chatId, message)
+		toSend.ParseMode = "HTML"
+		_, err := self.bot.Send(toSend)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

telegram_utils_test.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"html/template"
+	"io"
+	"log"
+	"testing"
+
+	"git.sr.ht/~michalr/go-satel"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+	"github.com/stretchr/testify/assert"
+)
+
+type MockTgBotAPI struct {
+	callCount int
+}
+
+func (self *MockTgBotAPI) Send(c tgbotapi.Chattable) (tgbotapi.Message, error) {
+	self.callCount += 1
+	return tgbotapi.Message{}, nil
+}
+
+var (
+	tgSenderMessageTest1 = satel.BasicEventElement{Type: satel.ArmedPartition, Index: 1, Value: true}
+)
+
+func TestTelegramSender_NoChatIdsWontSendAnything(t *testing.T) {
+	a := assert.New(t)
+	tpl := template.Must(template.New("TelegramMessage").Parse(""))
+	mockBot := MockTgBotAPI{0}
+
+	tested := TgSender{&mockBot, MockSatelNameGetter{"mockPart"}, log.New(io.Discard, "", 0), []int64{}}
+	tested.Send(GenericMessage{[]satel.BasicEventElement{tgSenderMessageTest1}}, tpl)
+	a.Equal(0, mockBot.callCount)
+}

templates_test.go

@@ -47,7 +47,7 @@ func TestTelegramTemplate(t *testing.T) {
 	tpl, err := template.New("TestTemplate").Parse(TelegramMessageTemplate)
 	assert.NoError(t, err)
 	Consume(SendToTg(testEvents, &mockSender, &wg, log.New(io.Discard, "", log.Ltime), tpl))
-	testEvents <- GenericMessage{TgChatId{123}, []satel.BasicEventElement{tplMessageTest1, tplMessageTest2}}
+	testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest1, tplMessageTest2}}
 	close(testEvents)
 	wg.Wait()