Merge pull request #7 from 0ne-zero/0-notification

Implement scalable notification mechanism

Author: ohmydevops

Makefile

@@ -1,16 +1,19 @@
 OUTPUT_DIR = build
-SOURCE = ./
+SOURCE = ./cmd/radar-notif/
 
 all: linux windows mac
 
 linux:
 	GOOS=linux GOARCH=amd64 go build -o $(OUTPUT_DIR)/radar-linux $(SOURCE)
+	cp icon.png $(OUTPUT_DIR)
 
 windows:
 	GOOS=windows GOARCH=amd64 go build -o $(OUTPUT_DIR)/radar-windows.exe $(SOURCE)
+	cp icon.png $(OUTPUT_DIR)
 
 mac:
 	GOOS=darwin GOARCH=amd64 go build -o $(OUTPUT_DIR)/radar-mac $(SOURCE)
+	cp icon.png $(OUTPUT_DIR)
 
 clean:
 	rm -rf $(OUTPUT_DIR)

cmd/radar-notif/main.go

@@ -0,0 +1,138 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	internal_flag "github.com/ohmydevops/arvancloud-radar-notif/internal/flag"
+	"github.com/ohmydevops/arvancloud-radar-notif/internal/notification"
+	"github.com/ohmydevops/arvancloud-radar-notif/radar"
+)
+
+const ProgramName = "📡 Arvan Cloud Radar Monitor"
+
+// Max consecutive errors to consider outage
+const maxConsecutiveErrorsForOutage = 3
+const notificationIconPath = "./icon.png"
+
+var (
+	DatacenterErrorCounts = make(map[radar.Datacenter]int)
+	erroredDatacenters    = make(map[radar.Datacenter]bool)
+	mu                    sync.Mutex // protects DatacenterErrorCounts & erroredDatacenters
+)
+
+func main() {
+	cfg, err := internal_flag.ParseFlags()
+	if err != nil {
+		fmt.Println("❌", err)
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	if cfg.ShowServices {
+		printServices()
+		os.Exit(0)
+	}
+
+	// Create notification manager
+	notifiers := []notification.Notifier{
+		notification.NewConsoleNotifier(),
+	}
+	if cfg.DesktopNotification {
+		notifiers = append(notifiers, notification.NewDesktopNotofier(ProgramName, notificationIconPath))
+	}
+	notifiersManager := notification.NewNotofiersManager(notifiers)
+
+	fmt.Println(ProgramName)
+
+	fmt.Printf("✅ Monitoring service: %s\n\n", capitalizeFirst(cfg.Service))
+
+	// performDelay(cfg.CheckDelay)
+
+	for {
+		fmt.Printf("⏰ %s\n", time.Now().Format("15:04:05"))
+
+		var wg sync.WaitGroup
+
+		for _, datacenter := range radar.AllDatacenters {
+			wg.Add(1)
+			go func(dc radar.Datacenter) {
+				defer wg.Done()
+				checkDatacenter(dc, radar.Service(cfg.Service), notifiersManager)
+			}(datacenter)
+		}
+
+		wg.Wait()
+
+		performDelay(cfg.CheckDelay)
+	}
+}
+
+// checkDatacenter handles checking & notification for a single datacenter
+func checkDatacenter(datacenter radar.Datacenter, service radar.Service, notifiersManager *notification.NotifiersManager) {
+
+	// Retrieve connectivity statistics between the datacenter and the service
+	stats, err := radar.CheckDatacenterServiceStatistics(datacenter, service)
+	if err != nil {
+		fmt.Printf("⚠️ Statistics: %v from [%s]\n", err, datacenter)
+		return
+	}
+
+	// Prevents race condition
+	mu.Lock()
+	defer mu.Unlock()
+
+	if stats.IsAccessibleNow() {
+		if erroredDatacenters[datacenter] {
+			title := "🟢 Internet Restored"
+			msg := fmt.Sprintf("%s is reachable again from %s", capitalizeFirst(string(service)), datacenter)
+
+			// Notify through notification mechanisms
+			if err := notifiersManager.Notify(title, msg); err != nil {
+				log.Printf("❌ Notification: %v from [%s]", err, datacenter)
+			}
+		}
+		erroredDatacenters[datacenter] = false
+		DatacenterErrorCounts[datacenter] = 0
+	} else {
+		DatacenterErrorCounts[datacenter]++
+		if DatacenterErrorCounts[datacenter] >= maxConsecutiveErrorsForOutage && !erroredDatacenters[datacenter] {
+			title := "🔴 Internet Outage"
+			msg := fmt.Sprintf("%s is unreachable from %s", capitalizeFirst(string(service)), datacenter)
+
+			// Notify through notification mechanisms
+			if err := notifiersManager.Notify(title, msg); err != nil {
+				fmt.Printf("❌ Notification: %v from [%s]", err, datacenter)
+			}
+			erroredDatacenters[datacenter] = true
+		}
+	}
+}
+
+// printServices prints available services
+func printServices() {
+	fmt.Println("Available services:")
+	for _, s := range radar.AllServices {
+		fmt.Printf("  - %s\n", s)
+	}
+
+}
+
+// performDelay sleeps for the specified number of minutes
+func performDelay(minutes int) {
+	time.Sleep(time.Duration(minutes) * time.Minute)
+	// time.Sleep(5 * time.Second)
+}
+
+// capitalizeFirst makes the first letter uppercase
+func capitalizeFirst(s string) string {
+	if len(s) == 0 {
+		return s
+	}
+	return strings.ToUpper(s[:1]) + s[1:]
+}

flag.go

@@ -0,0 +1,63 @@
+package flag
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/ohmydevops/arvancloud-radar-notif/radar"
+)
+
+const DefaultCheckDelay = 1
+const DefaultDesktopNotif = true
+
+type Config struct {
+	Service             string
+	ShowServices        bool
+	CheckDelay          int // In minutes
+	DesktopNotification bool
+}
+
+func NewConfig() Config {
+	return Config{
+		CheckDelay:          DefaultCheckDelay,
+		DesktopNotification: DefaultDesktopNotif,
+	}
+}
+
+func ParseFlags() (*Config, error) {
+	var cfg Config = NewConfig()
+
+	flag.StringVar(&cfg.Service, "service", "", "Service name to monitor (e.g. google, github, etc.)")
+	flag.BoolVar(&cfg.ShowServices, "services", false, "Show list of available services")
+	flag.IntVar(&cfg.CheckDelay, "delay", DefaultCheckDelay, "Delay between checks in minutes")
+
+	// Negative flag disables notifications, so bind to a local variable and invert it
+	disableDesktopNotif := flag.Bool("no-desktop-notif", false, "Disable desktop notifications")
+
+	flag.Parse()
+
+	// Apply negative flag to DesktopNotification
+	cfg.DesktopNotification = !(*disableDesktopNotif)
+
+	if cfg.ShowServices {
+		return &cfg, nil
+	}
+
+	// normalize to lowercase
+	cfg.Service = strings.ToLower(cfg.Service)
+
+	if cfg.Service == "" {
+		return nil, errors.New("must specify a service")
+	}
+	// Validate service
+	if _, ok := radar.ParseService(cfg.Service); !ok {
+		return nil, fmt.Errorf("invalid service: %s", cfg.Service)
+	}
+
+	if cfg.CheckDelay < 1 {
+		return nil, fmt.Errorf("delay must be greater than 0")
+	}
+	return &cfg, nil
+}

internal/flag/flag.go

@@ -0,0 +1,76 @@
+package notification
+
+import (
+	"fmt"
+
+	"github.com/gen2brain/beeep"
+)
+
+// Notifier is an interface for different notification backends.
+// Only cares about getting the final title + message.
+type Notifier interface {
+	Notify(title string, message string) error
+}
+
+// NotifiersManager combines multiple notifiers into one.
+type NotifiersManager struct {
+	Notifiers []Notifier
+}
+
+func NewNotofiersManager(notifiers []Notifier) *NotifiersManager {
+	return &NotifiersManager{
+		Notifiers: notifiers,
+	}
+}
+
+func (m *NotifiersManager) Notify(title, message string) error {
+	for _, n := range m.Notifiers {
+		if err := n.Notify(title, message); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ConsoleNotifier prints logs on console.
+type ConsoleNotifier struct {
+}
+
+func NewConsoleNotifier() *ConsoleNotifier {
+	return &ConsoleNotifier{}
+}
+func (c *ConsoleNotifier) Notify(title, message string) error {
+	_, err := fmt.Printf("[%s] %s\n", title, message)
+	return err
+}
+
+// DesktopNotifier sends desktop notifications using beeep.
+type DesktopNotifier struct {
+	IconPath          string
+	NotificationTitle string
+}
+
+func NewDesktopNotofier(NotificationTitle, iconPath string) *DesktopNotifier {
+	return &DesktopNotifier{
+		IconPath:          iconPath,
+		NotificationTitle: NotificationTitle,
+	}
+}
+
+func (d *DesktopNotifier) Notify(title, message string) error {
+	if beeep.AppName != d.NotificationTitle {
+		beeep.AppName = d.NotificationTitle
+	}
+	if err := beeep.Notify(title, message, d.IconPath); err != nil {
+		return fmt.Errorf("desktop notification error: %v", err)
+	}
+	return nil
+}
+
+// Future backends:
+//
+// type EmailNotifier struct{}
+// func (e *EmailNotifier) Notify(title, message string) error { ... }
+//
+// type TelegramNotifier struct{}
+// func (s *SlackNotifier) Notify(title, message string) error { ... }