Merge pull request #6 from 0ne-zero/0-refactor

Codebase refactored

Author: ohmydevops

Makefile

@@ -1,5 +1,5 @@
 OUTPUT_DIR = build
-SOURCE = main.go
+SOURCE = ./
 
 all: linux windows mac
 

flag.go

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"strings"
+
+	"github.com/ohmydevops/arvancloud-radar-notif/radar"
+)
+
+type Config struct {
+	Service      string
+	ShowServices bool
+}
+
+func parseFlags() (*Config, error) {
+	var cfg Config
+
+	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.Parse()
+
+	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)
+	}
+	return &cfg, nil
+}

go.mod

@@ -1,4 +1,4 @@
-module arvancloud-radar-notif
+module github.com/ohmydevops/arvancloud-radar-notif
 
 go 1.24.5
 

main.go

@@ -1,186 +1,117 @@
 package main
 
 import (
-	"encoding/json"
 	"flag"
 	"fmt"
-	"io"
-	"net/http"
-	"net/http/cookiejar"
+	"log"
 	"os"
+	"sync"
 	"time"
 
 	"github.com/gen2brain/beeep"
+	"github.com/ohmydevops/arvancloud-radar-notif/radar"
 )
 
-const baseURL = "https://radar.arvancloud.ir/api/v1/internet-monitoring?isp="
+// Max consecutive errors to consider outage
+const maxISPError = 3
 
 var (
-	errorCounts        = make(map[string]int)
-	erroredDataCenters = make(map[string]bool)
-	serviceIndicator   string
+	ISPErrorCounts = make(map[radar.Datacenter]int)
+	erroredISPs    = make(map[radar.Datacenter]bool)
+	mu             sync.Mutex // protects ISPErrorCounts & erroredISPs
 )
 
-var availableServices = []string{
-	"google",
-	"wikipedia",
-	"playstation",
-	"bing",
-	"github",
-	"digikala",
-	"divar",
-	"aparat",
-}
-
-var dataCenters = []string{
-	"sindad-buf",
-	"sindad-thr-fanava",
-	"sindad-thr",
-	"bertina-xrx",
-	"ajk-abrbaran",
-	"tehran-3",
-	"tehran-2",
-	"bertina-thr",
-	"hostiran",
-	"parsonline",
-	"afranet",
-	"mci",
-	"irancell",
-}
-
-func printServices() {
-	fmt.Println("Usage:")
-	fmt.Println("  --service=N       Run directly without prompt, where N is the service number (see below)")
-	fmt.Println("  --help            Show this help message and available services")
-	fmt.Println()
-	fmt.Println("Available services:")
-	for i, s := range availableServices {
-		fmt.Printf("  %2d) %s\n", i+1, s)
+func main() {
+	cfg, err := parseFlags()
+	if err != nil {
+		fmt.Println("❌", err)
+		flag.Usage()
+		os.Exit(1)
 	}
-	fmt.Println()
-	fmt.Println("Examples:")
-	fmt.Println("  ./radar-linux                # Interactive mode (asks for service)")
-	fmt.Println("  ./radar-linux --service=3    # Monitor playstation directly")
-	fmt.Println("  ./radar-linux --help         # Show this help message")
-}
 
-func chooseServiceInteractive() string {
-	printServices()
-	var choice int
-	fmt.Print("Enter number: ")
-	_, err := fmt.Scanln(&choice)
-	if err != nil || choice < 1 || choice > len(availableServices) {
-		fmt.Println("⚠️ Invalid choice. Defaulting to 'google'")
-		return "google"
+	if cfg.ShowServices {
+		printServices()
+		os.Exit(0)
 	}
-	return availableServices[choice-1]
-}
 
-func fetchData(client *http.Client, dataCenter string) (float64, error) {
-	url := baseURL + dataCenter
+	fmt.Println("📡 Arvan Cloud Radar Monitor")
+
+	fmt.Printf("✅ Monitoring service: %s\n", cfg.Service)
 
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return 0, fmt.Errorf("⚠️ request creation error: %v", err)
-	}
+	waitUntilNextMinute()
 
-	resp, err := client.Do(req)
-	if err != nil {
-		return 0, fmt.Errorf("⚠️ request error: %v", err)
-	}
-	defer resp.Body.Close()
+	for {
+		fmt.Printf("⏰ %s\n", time.Now().Format("15:04:05"))
 
-	if resp.StatusCode != http.StatusOK {
-		return 0, fmt.Errorf("⚠️ unexpected status code: %d", resp.StatusCode)
-	}
+		var wg sync.WaitGroup
 
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return 0, fmt.Errorf("⚠️ error reading response: %v", err)
-	}
+		for _, isp := range radar.AllDatacenters {
+			wg.Add(1)
+			go func(isp radar.Datacenter) {
+				defer wg.Done()
+				checkISP(isp, radar.Service(cfg.Service))
+			}(isp)
+		}
 
-	var data map[string][]float64
-	if err := json.Unmarshal(body, &data); err != nil {
-		return 0, fmt.Errorf("⚠️ JSON parse error: %v", err)
+		wg.Wait()
+		time.Sleep(1 * time.Minute)
 	}
+}
 
-	values, ok := data[serviceIndicator]
-	if !ok || values == nil || len(values) == 0 {
-		return 0, fmt.Errorf("-")
+// checkISP handles checking & notification for a single ISP
+func checkISP(isp radar.Datacenter, service radar.Service) {
+	stats, err := radar.CheckDatacenterServiceStatistics(isp, service)
+	if err != nil {
+		fmt.Printf("[%s] ⚠️ %v\n", isp, err)
+		return
 	}
 
-	return values[len(values)-1], nil
-}
+	mu.Lock()
+	defer mu.Unlock()
 
-func checkStatus(dataCenter string, value float64) {
-	fmt.Printf("[%s] => Value: %.2f\n", dataCenter, value)
-	beeep.AppName = "Arvan Cloud Radar"
-	if value != 0 {
-		errorCounts[dataCenter]++
-		if errorCounts[dataCenter] >= 3 && !erroredDataCenters[dataCenter] {
-			err := beeep.Notify("🔴 Internet Outage", fmt.Sprintf("%s unreachable from %s", serviceIndicator, dataCenter), "./icon.png")
-			if err != nil {
-				fmt.Printf("[%s] ⚠️ Notification error: %v\n", dataCenter, err)
-			}
-			erroredDataCenters[dataCenter] = true
+	if stats.IsAccessibleNow() {
+		if erroredISPs[isp] {
+			notifyRestored(service, isp)
 		}
+		erroredISPs[isp] = false
+		ISPErrorCounts[isp] = 0
 	} else {
-		if erroredDataCenters[dataCenter] {
-			err := beeep.Notify("🟢 Internet Restored", fmt.Sprintf("%s is reachable again from %s", serviceIndicator, dataCenter), "./icon.png")
-			if err != nil {
-				fmt.Printf("[%s] ⚠️ Notification error: %v\n", dataCenter, err)
-			}
-			fmt.Printf("[%s] 🟢 %s is reachable again\n", dataCenter, serviceIndicator)
+		ISPErrorCounts[isp]++
+		if ISPErrorCounts[isp] > maxISPError && !erroredISPs[isp] {
+			notifyOutage(service, isp)
+			erroredISPs[isp] = true
 		}
-		errorCounts[dataCenter] = 0
-		erroredDataCenters[dataCenter] = false
 	}
 }
 
-func waitUntilNextMinute() {
-	now := time.Now()
-	delay := time.Until(now.Truncate(time.Minute).Add(time.Minute))
-	time.Sleep(delay)
+// notifyOutage sends notification when service becomes unreachable
+func notifyOutage(service radar.Service, isp radar.Datacenter) {
+	msg := fmt.Sprintf("%s unreachable from %s", service, isp)
+	if err := beeep.Notify("🔴 Internet Outage", msg, "./icon.png"); err != nil {
+		fmt.Printf("[%s] ❌ Notification error: %v", isp, err)
+	}
+	fmt.Printf("[%s] 🔴 %s outage detected", isp, service)
 }
 
-func main() {
-	fmt.Println("📡 Arvan Cloud Radar Monitor")
-	serviceFlag := flag.Int("service", 0, "Service number to monitor (e.g. 1 for google, 2 for wikipedia...)")
-	helpFlag := flag.Bool("help", false, "Show available services")
-	flag.Parse()
-
-	if *helpFlag {
-		printServices()
-		return
+// notifyRestored sends notification when service is reachable again
+func notifyRestored(service radar.Service, isp radar.Datacenter) {
+	msg := fmt.Sprintf("%s is reachable again from %s", service, isp)
+	if err := beeep.Notify("🟢 Internet Restored", msg, "./icon.png"); err != nil {
+		log.Printf("[%s] ❌ Notification error: %v", isp, err)
 	}
+	log.Printf("[%s] 🟢 %s restored", isp, service)
+}
 
-	if *serviceFlag > 0 && *serviceFlag <= len(availableServices) {
-		serviceIndicator = availableServices[*serviceFlag-1]
-	} else if *serviceFlag != 0 {
-		fmt.Println("⚠️ Invalid service number. Use --help to see available options.")
-		os.Exit(1)
-	} else {
-		serviceIndicator = chooseServiceInteractive()
+// printServices prints available services
+func printServices() {
+	fmt.Println("Available services:")
+	for _, s := range radar.AllServices {
+		fmt.Printf("  - %s\n", s)
 	}
 
-	fmt.Printf("✅ Monitoring service: %s\n", serviceIndicator)
-
-	jar, _ := cookiejar.New(nil)
-	client := &http.Client{Jar: jar}
+}
 
-	waitUntilNextMinute()
-	for {
-		fmt.Printf("⏰ %s\n", time.Now().Format("15:04:05"))
-		for _, dataCenter := range dataCenters {
-			go func(dc string) {
-				value, err := fetchData(client, dc)
-				if err != nil {
-					fmt.Printf("[%s] %v\n", dc, err)
-					return
-				}
-				checkStatus(dc, value)
-			}(dataCenter)
-		}
-		time.Sleep(1 * time.Minute)
-	}
+// waitUntilNextMinute sleeps until next full minute
+func waitUntilNextMinute() {
+	time.Sleep(time.Until(time.Now().Truncate(time.Minute).Add(time.Minute)))
 }