add notify-send cmd; tests

Author: shayanderson

Makefile

@@ -1,22 +1,51 @@
 .DEFAULT_GOAL := help
 
 PROJECT := notifymem
+BINARY := bin/$(PROJECT)-linux-amd64
 SOURCES := $(wildcard *.go cmd/*/*.go)
-VERSION := $(shell git describe --tags 2>/dev/null || echo "Unknown")
+VERSION := $(shell git describe --tags --abbrev=0 2>/dev/null || echo "Unknown")
 
 build: $(SOURCES) ## Build the project
 	@echo "Building $(PROJECT) ($(VERSION))"
-	CGO_ENABLED=0 go build -ldflags "-X 'main.version=$(VERSION)'" -o bin/$(PROJECT) cmd/notifymem/*.go
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "-X 'main.version=$(VERSION)'" -o $(BINARY) cmd/notifymem/*.go
 
 .PHONY: help
 help: ## Display help
 	@COL_W=20
 	@grep -h '##' $(MAKEFILE_LIST) | \
 	  grep -v grep | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-'$$COL_W's\033[0m %s\n", $$1, $$2}'
 
+.PHONY: logs
+logs:
+	journalctl -u $(PROJECT) -f
+
+.PHONY: reload
+reload:
+	sudo systemctl daemon-reload
+
+.PHONY: restart
+restart:
+	sudo systemctl restart $(PROJECT)
+
 .PHONY: run
 run: build ## Run the project
-	./bin/$(PROJECT)
+	./$(BINARY)
+
+.PHONY: start
+start:
+	sudo systemctl start $(PROJECT)
+
+.PHONY: status
+status:
+	sudo systemctl status $(PROJECT)
+
+.PHONY: stop
+stop:
+	sudo systemctl stop $(PROJECT)
+
+.PHONY: test
+test: ## Run tests
+	go test -v ./...
 
 .PHONY: tidy
 tidy: ## Run go mod tidy

README.md

@@ -10,10 +10,16 @@ Features:
 
 ## Usage
 
-Example usage that monitors memory usage by checking every 2 seconds, sends a notification when memory usage is above 80% and will not send another notification until after 60 seconds.
+Example usage that monitors memory usage by checking every 2 seconds, sends a notification when memory usage is above 80% and will not send another notification until after 10 seconds.
 
 ```bash
-notifymem -threshold 80 -delay 60 -interval 2
+notifymem -threshold 80 -delay 10 -interval 2
+```
+
+Run a test which will check memory usage and send a test notification:
+
+```bash
+notifymem -test
 ```
 
 ## Installation
@@ -25,14 +31,15 @@ Next, create a systemd service file in `/etc/systemd/system/notifymem.service` w
 ```ini
 [Unit]
 Description=notifymem service: notify when memory usage reaches a threshold
-After=network.target
+After=network.target,systemd-user-sessions.service,systemd-journald.service
 
 [Service]
 Type=simple
 Restart=always
 RestartSec=3
 User=your-username
-ExecStart=/opt/notifymem/bin/notifymem -threshold 80 -delay 60 -interval 2
+ExecStart=/opt/notifymem/bin/notifymem -threshold 80 -delay 30 -interval 2
+Environment="DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus"
 
 [Install]
 WantedBy=multi-user.target
@@ -42,6 +49,7 @@ Make sure to:
 
 - replace `your-username` with your actual username
 - set `ExecStart` to the path where you copied the binary and use the desired options
+- set `Environment` to the correct `DBUS_SESSION_BUS_ADDRESS` value for your system, which can be found by running `echo $DBUS_SESSION_BUS_ADDRESS`
 
 Finally, enable and start the service:
 

cmd/notifymem/main.go

@@ -24,13 +24,15 @@ func main() {
 		debug       bool
 		interval    int
 		resendDelay int
+		test        bool
 		threshold   int
 	}
 
 	f := flags{}
 	flag.BoolVar(&f.debug, "debug", false, "enable debug mode")
 	flag.IntVar(&f.interval, "interval", 2, "interval between memory checks in seconds")
-	flag.IntVar(&f.resendDelay, "delay", 30, "delay between notifications being sent in seconds")
+	flag.IntVar(&f.resendDelay, "delay", 10, "delay between notifications being sent in seconds")
+	flag.BoolVar(&f.test, "test", false, "run a test to check memory usage and send notification")
 	flag.IntVar(&f.threshold, "threshold", 80, "memory threshold as a percentage")
 	flag.Parse()
 
@@ -50,6 +52,14 @@ func main() {
 		errorExit(err)
 	}
 
+	if f.test {
+		err := m.Test()
+		if err != nil {
+			errorExit(err)
+		}
+		os.Exit(0)
+	}
+
 	ctx := context.Background()
 	if err := m.Run(ctx); err != nil && err != context.Canceled {
 		errorExit(err)

monitor.go

@@ -23,12 +23,13 @@ type MonitorOptions struct {
 }
 
 type Monitor struct {
-	debugFunc   func(string)
-	interval    time.Duration
-	lastSentAt  time.Time
-	notifier    Notifier
-	resendDelay time.Duration
-	threshold   int
+	debugFunc         func(string)
+	interval          time.Duration
+	lastSentAt        time.Time
+	notificationsSent int
+	notifier          Notifier
+	resendDelay       time.Duration
+	threshold         int
 }
 
 func NewMonitor(notifier Notifier, opts MonitorOptions) (*Monitor, error) {
@@ -63,12 +64,14 @@ func NewMonitor(notifier Notifier, opts MonitorOptions) (*Monitor, error) {
 	return m, nil
 }
 
+// debug prints a debug message when debug mode is enabled
 func (m *Monitor) debug(msg string) {
 	if m.debugFunc != nil {
 		m.debugFunc(msg)
 	}
 }
 
+// isThresholdReached checks if the memory usage threshold has been reached
 func (m *Monitor) isThresholdReached() (bool, int, error) {
 	mem, err := readMemory()
 	if err != nil {
@@ -87,20 +90,32 @@ func (m *Monitor) isThresholdReached() (bool, int, error) {
 	return false, usage, nil
 }
 
+// notify sends a notification if the resend delay has been reached
 func (m *Monitor) notify(usage int) error {
 	if time.Since(m.lastSentAt) < m.resendDelay {
 		m.debug("resend delay not reached")
 		return nil
 	}
 
 	m.debug("sending notification")
+	fmt.Printf("threshold reached: %d%%\n", usage)
+	nSentStr := ""
+	if m.notificationsSent > 0 {
+		nSentStr = fmt.Sprintf(" (%d)", m.notificationsSent)
+	}
 	m.lastSentAt = time.Now()
-	return m.notifier.Notify(
-		"Memory Usage Threshold Reached [notifymem]",
+	err := m.notifier.Notify(
+		"Memory Usage Threshold Reached [notifymem]"+nSentStr,
 		fmt.Sprintf("Memory usage at %d%%", usage),
 	)
+	m.notificationsSent++
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
+// Run starts the monitor
 func (m *Monitor) Run(ctx context.Context) error {
 	m.debug("staring monitor")
 	for {
@@ -117,7 +132,6 @@ func (m *Monitor) Run(ctx context.Context) error {
 			m.debug(fmt.Sprintf("memory usage: %d%%", usage))
 
 			if reached {
-				m.debug(fmt.Sprintf("threshold reached: %d%%", usage))
 				if err := m.notify(usage); err != nil {
 					return err
 				}
@@ -127,6 +141,18 @@ func (m *Monitor) Run(ctx context.Context) error {
 	}
 }
 
+// Test executes a test to check memory usage and send a notification
+func (m *Monitor) Test() error {
+	m.debug("running test")
+	_, usage, err := m.isThresholdReached()
+	if err != nil {
+		return err
+	}
+	m.notify(usage)
+	return nil
+}
+
+// memoryUsage calculates memory usage as a percentage
 func memoryUsage(m memory) (int, error) {
 	if m.total == 0 {
 		return 0, errors.New("total memory is 0")
@@ -135,6 +161,7 @@ func memoryUsage(m memory) (int, error) {
 	return int((float64(m.total-m.avail) / float64(m.total)) * 100), nil
 }
 
+// readMemory reads memory information from /proc/meminfo
 func readMemory() (memory, error) {
 	m := memory{}
 	f, err := os.Open("/proc/meminfo")

monitor_test.go

@@ -0,0 +1,74 @@
+package notifymem
+
+import (
+	"testing"
+	"time"
+)
+
+func TestNewMonitor(t *testing.T) {
+	// test NewMonitor
+	n := NewNotifier()
+	mOpts := MonitorOptions{
+		Interval:    2 * time.Second,
+		ResendDelay: 30 * time.Second,
+		Threshold:   80,
+	}
+	_, err := NewMonitor(n, mOpts)
+	if err != nil {
+		t.Fatalf("expected nil, got: %s", err)
+	}
+
+	mOpts.Interval = 0 * time.Millisecond
+	_, err = NewMonitor(n, mOpts)
+	if err == nil {
+		t.Fatalf("expected bad interval error, got nil")
+	}
+
+	mOpts.Interval = 2 * time.Second
+	mOpts.ResendDelay = 0 * time.Second
+	_, err = NewMonitor(n, mOpts)
+	if err == nil {
+		t.Fatalf("expected bad resend delay error, got nil")
+	}
+
+	mOpts.ResendDelay = 30 * time.Second
+	mOpts.Threshold = -1
+	_, err = NewMonitor(n, mOpts)
+	if err == nil {
+		t.Fatalf("expected bad threshold error, got nil")
+	}
+}
+
+type mockNotifier struct {
+	notifyCalled bool
+}
+
+func (m *mockNotifier) Notify(title, message string) error {
+	m.notifyCalled = true
+	return nil
+}
+
+func TestMonitorNotify(t *testing.T) {
+	// test Monitor.Notify
+	m := &Monitor{}
+	m.notifier = &mockNotifier{}
+	m.notify(80)
+	if !m.notifier.(*mockNotifier).notifyCalled {
+		t.Fatalf("expected notify to be called")
+	}
+}
+func TestMemoryUsage(t *testing.T) {
+	mem := memory{
+		total: 100,
+		avail: 50,
+	}
+
+	usage, err := memoryUsage(mem)
+	if err != nil {
+		t.Fatalf("expected nil, got: %s", err)
+	}
+
+	if usage != 50 {
+		t.Fatalf("expected 50, got: %d", usage)
+	}
+}

notifier.go

@@ -1,6 +1,8 @@
 package notifymem
 
-import "fmt"
+import (
+	"os/exec"
+)
 
 type Notifier interface {
 	Notify(title, message string) error
@@ -13,7 +15,12 @@ func NewNotifier() *notifier {
 	return &notifier{}
 }
 
+// Notify sends a notification using notify-send
 func (n *notifier) Notify(title, message string) error {
-	fmt.Println("notify:", title, message)
+	cmd := exec.Command("notify-send", title, message)
+	err := cmd.Run()
+	if err != nil {
+		return err
+	}
 	return nil
 }