Initial poc commit.

config.yaml

@@ -0,0 +1,12 @@
+input_file: "http://localhost:8080"
+# input_file: "./ips.txt"
+# input_file: /run/ping_service/input.sock
+
+output_file: "http://localhost:8081"
+# output_file: "results.json"
+# output_file: /run/ping_service/output.sock
+
+interval_seconds: 30
+cooldown_minutes: 10
+enable_traceroute: true
+traceroute_max_hops: 30

input_http_server.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""
+HTTP Input Server - Serves IPs one per request from a list
+Usage: python3 http_input_server.py
+"""
+
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import itertools
+import signal
+import sys
+
+# List of IPs to serve (rotates through them)
+IPS = [
+    "8.8.8.8",
+    "1.1.1.1",
+    "208.67.222.222",
+    "9.9.9.9",
+    "8.8.4.4"
+]
+
+ip_cycle = itertools.cycle(IPS)
+
+class InputHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        ip = next(ip_cycle)
+        print(f"[INPUT] Serving IP: {ip}")
+        
+        self.send_response(200)
+        self.send_header('Content-Type', 'text/plain')
+        self.end_headers()
+        self.wfile.write(f"{ip}\n".encode())
+    
+    def log_message(self, format, *args):
+        # Suppress default logging
+        pass
+
+def signal_handler(sig, frame):
+    print("\n\n🛑 Shutting down gracefully...")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    PORT = 8080
+    
+    # Register signal handlers for graceful shutdown
+    signal.signal(signal.SIGINT, signal_handler)   # Ctrl+C
+    signal.signal(signal.SIGTERM, signal_handler)  # kill command
+    
+    server = HTTPServer(('0.0.0.0', PORT), InputHandler)
+    print(f"🌐 HTTP Input Server running on http://localhost:{PORT}")
+    print(f"   Serving IPs in rotation: {IPS}")
+    print(f"   Press Ctrl+C to stop")
+    
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        print("\n✅ Server stopped cleanly")

output_http_server.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+HTTP Output Server - Receives POST requests with JSON ping results
+Usage: python3 http_output_server.py
+"""
+
+from http.server import HTTPServer, BaseHTTPRequestHandler
+import json
+import signal
+import sys
+from datetime import datetime
+
+class OutputHandler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        content_length = int(self.headers['Content-Length'])
+        post_data = self.rfile.read(content_length)
+        
+        print(f"\n{'='*60}")
+        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Received POST request")
+        print(f"{'='*60}")
+        
+        try:
+            data = json.loads(post_data)
+            print(json.dumps(data, indent=2))
+            
+            # Summary
+            print(f"\n📊 Summary:")
+            if isinstance(data, list):
+                print(f"   Total results: {len(data)}")
+                for result in data:
+                    ip = result.get('ip', 'unknown')
+                    loss = result.get('packet_loss', 0)
+                    avg_rtt = result.get('avg_rtt', 0)
+                    error = result.get('error', '')
+                    traceroute = result.get('traceroute')
+                    
+                    if error:
+                        print(f"   ❌ {ip}: ERROR - {error}")
+                    else:
+                        rtt_ms = avg_rtt / 1_000_000  # Convert ns to ms
+                        print(f"   ✅ {ip}: {loss}% loss, avg RTT: {rtt_ms:.2f}ms")
+                        
+                        if traceroute:
+                            hops = traceroute.get('hops', [])
+                            method = traceroute.get('method', 'unknown')
+                            print(f"      🛤️  Traceroute ({method}): {len(hops)} hops")
+                            for hop in hops[:5]:  # Show first 5 hops
+                                ttl = hop.get('ttl')
+                                hop_ip = hop.get('ip', '*')
+                                if hop.get('timeout'):
+                                    print(f"         {ttl}. * (timeout)")
+                                else:
+                                    hop_rtt = hop.get('rtt', 0) / 1_000_000
+                                    print(f"         {ttl}. {hop_ip} ({hop_rtt:.2f}ms)")
+                            if len(hops) > 5:
+                                print(f"         ... and {len(hops) - 5} more hops")
+        except json.JSONDecodeError:
+            print("⚠️  Invalid JSON received")
+            print(post_data.decode('utf-8', errors='replace'))
+        
+        print(f"{'='*60}\n")
+        
+        # Send response
+        self.send_response(200)
+        self.send_header('Content-Type', 'application/json')
+        self.end_headers()
+        self.wfile.write(b'{"status": "received"}')
+    
+    def log_message(self, format, *args):
+        # Suppress default logging
+        pass
+
+def signal_handler(sig, frame):
+    print("\n\n🛑 Shutting down gracefully...")
+    sys.exit(0)
+
+if __name__ == "__main__":
+    PORT = 8081
+    
+    # Register signal handlers for graceful shutdown
+    signal.signal(signal.SIGINT, signal_handler)   # Ctrl+C
+    signal.signal(signal.SIGTERM, signal_handler)  # kill command
+    
+    server = HTTPServer(('0.0.0.0', PORT), OutputHandler)
+    print(f"📥 HTTP Output Server running on http://localhost:{PORT}")
+    print(f"   Waiting for POST requests with ping results...")
+    print(f"   Press Ctrl+C to stop")
+    
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        print("\n✅ Server stopped cleanly")

ping_service.go

@@ -0,0 +1,428 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/go-ping/ping"
+	"gopkg.in/yaml.v3"
+)
+
+type Config struct {
+	InputFile       string `yaml:"input_file"`
+	OutputFile      string `yaml:"output_file"`
+	IntervalSeconds int    `yaml:"interval_seconds"`
+	CooldownMinutes int    `yaml:"cooldown_minutes"`
+	EnableTraceroute bool  `yaml:"enable_traceroute"`
+	TracerouteMaxHops int  `yaml:"traceroute_max_hops"`
+}
+
+type PingResult struct {
+	IP         string        `json:"ip"`
+	Sent       int           `json:"sent"`
+	Received   int           `json:"received"`
+	PacketLoss float64       `json:"packet_loss"`
+	AvgRtt     time.Duration `json:"avg_rtt"`
+	Timestamp  time.Time     `json:"timestamp"`
+	Error      string        `json:"error,omitempty"`
+	Traceroute *TracerouteResult `json:"traceroute,omitempty"`
+}
+
+type TracerouteResult struct {
+	Method    string         `json:"method"` // "icmp" or "tcp"
+	Hops      []TracerouteHop `json:"hops"`
+	Completed bool           `json:"completed"`
+	Error     string         `json:"error,omitempty"`
+}
+
+type TracerouteHop struct {
+	TTL     int           `json:"ttl"`
+	IP      string        `json:"ip"`
+	Rtt     time.Duration `json:"rtt,omitempty"`
+	Timeout bool          `json:"timeout,omitempty"`
+}
+
+var (
+	// cooldownCache stores IP -> last ping time
+	cooldownCache = make(map[string]time.Time)
+	cacheMux      sync.Mutex
+	verbose       bool
+)
+
+func main() {
+	// CLI flags
+	configPath := flag.String("config", "config.yaml", "Path to config file")
+	verboseFlag := flag.Bool("v", false, "Enable verbose logging")
+	flag.BoolVar(verboseFlag, "verbose", false, "Enable verbose logging")
+	help := flag.Bool("help", false, "Show help message")
+	flag.Parse()
+
+	if *help {
+		fmt.Println("Ping Service - Monitor network endpoints via ping")
+		fmt.Println("\nUsage:")
+		flag.PrintDefaults()
+		fmt.Println("\nConfig file format (YAML):")
+		fmt.Println("  input_file: Path/URL to file containing IPs (one per line)")
+		fmt.Println("  output_file: Path/URL/socket for JSON results")
+		fmt.Println("  interval_seconds: How often to check for new IPs")
+		fmt.Println("  cooldown_minutes: Minimum time between pings for same IP")
+		fmt.Println("  enable_traceroute: Enable traceroute after successful ping")
+		fmt.Println("  traceroute_max_hops: Maximum TTL for traceroute (default: 30)")
+		os.Exit(0)
+	}
+
+	verbose = *verboseFlag
+
+	config := loadConfig(*configPath)
+	if config.CooldownMinutes == 0 {
+		config.CooldownMinutes = 10
+	}
+	if config.TracerouteMaxHops == 0 {
+		config.TracerouteMaxHops = 30
+	}
+
+	ticker := time.NewTicker(time.Duration(config.IntervalSeconds) * time.Second)
+	log.Printf("App started. Cooldown set to %d mins. Polling every %ds...", config.CooldownMinutes, config.IntervalSeconds)
+	if config.EnableTraceroute {
+		log.Printf("Traceroute enabled (max %d hops)", config.TracerouteMaxHops)
+	}
+
+	for {
+		process(config)
+		<-ticker.C
+	}
+}
+
+func loadConfig(path string) *Config {
+	f, err := os.ReadFile(path)
+	if err != nil {
+		log.Fatalf("Error reading config: %v", err)
+	}
+	var cfg Config
+	err = yaml.Unmarshal(f, &cfg)
+	if err != nil {
+		log.Fatalf("Error parsing config: %v", err)
+	}
+	return &cfg
+}
+
+func process(cfg *Config) {
+	// 1. Read IPs
+	data, err := readSource(cfg.InputFile)
+	if err != nil {
+		log.Printf("Input Error: %v", err)
+		return
+	}
+	rawIps := strings.Fields(string(data))
+
+	if verbose {
+		log.Printf("Read %d IPs from %s", len(rawIps), cfg.InputFile)
+	}
+
+	// Filter IPs based on cooldown
+	var ipsToPing []string
+	cacheMux.Lock()
+	for _, ip := range rawIps {
+		if last, ok := cooldownCache[ip]; ok {
+			if time.Since(last) < time.Duration(cfg.CooldownMinutes)*time.Minute {
+				if verbose {
+					log.Printf("Skipping %s (cooldown: %v remaining)", ip, time.Duration(cfg.CooldownMinutes)*time.Minute-time.Since(last))
+				}
+				continue // Skip this IP
+			}
+		}
+		ipsToPing = append(ipsToPing, ip)
+		cooldownCache[ip] = time.Now()
+	}
+	cacheMux.Unlock()
+
+	if len(ipsToPing) == 0 {
+		if verbose {
+			log.Println("No IPs to ping (all in cooldown)")
+		}
+		return
+	}
+
+	if verbose {
+		log.Printf("Pinging %d IPs: %v", len(ipsToPing), ipsToPing)
+	}
+
+	// 2. Perform Pings
+	var wg sync.WaitGroup
+	results := make([]PingResult, len(ipsToPing))
+
+	for i, ip := range ipsToPing {
+		wg.Add(1)
+		go func(idx int, targetIP string) {
+			defer wg.Done()
+			results[idx] = runPing(targetIP)
+
+			// If ping successful and traceroute enabled, do traceroute
+			if cfg.EnableTraceroute && results[idx].Error == "" && results[idx].Received > 0 {
+				if verbose {
+					log.Printf("Running traceroute to %s...", targetIP)
+				}
+				results[idx].Traceroute = runTraceroute(targetIP, cfg.TracerouteMaxHops)
+			}
+
+			if verbose {
+				if results[idx].Error != "" {
+					log.Printf("Pinged %s: ERROR - %s", results[idx].IP, results[idx].Error)
+				} else {
+					log.Printf("Pinged %s: %d/%d packets, %.2f%% loss, avg RTT: %v",
+						results[idx].IP, results[idx].Received, results[idx].Sent,
+						results[idx].PacketLoss, results[idx].AvgRtt)
+					if results[idx].Traceroute != nil {
+						log.Printf("  Traceroute: %d hops via %s", len(results[idx].Traceroute.Hops), results[idx].Traceroute.Method)
+					}
+				}
+			}
+		}(i, ip)
+	}
+	wg.Wait()
+
+	// 3. Write Output
+	outputData, _ := json.MarshalIndent(results, "", "  ")
+	err = writeDestination(cfg.OutputFile, outputData)
+	if err != nil {
+		log.Printf("Output Error: %v", err)
+	} else if verbose {
+		log.Printf("Wrote results to %s", cfg.OutputFile)
+	}
+}
+
+// Logic: If socket exists, dial it. If not, listen on it.
+func handleSocket(path string, data []byte, mode string) ([]byte, error) {
+	if _, err := os.Stat(path); err == nil {
+		// SOCKET EXISTS: Connect as Client
+		conn, err := net.DialTimeout("unix", path, 2*time.Second)
+		if err != nil {
+			// If we can't connect, the socket might be "stale" (file exists but no one listening)
+			os.Remove(path)
+			return handleSocket(path, data, mode) // Recursive call to create listener
+		}
+		defer conn.Close()
+
+		if mode == "read" {
+			return io.ReadAll(conn)
+		} else {
+			_, err = conn.Write(data)
+			return nil, err
+		}
+	} else {
+		// SOCKET DOES NOT EXIST: Create as Server
+		l, err := net.Listen("unix", path)
+		if err != nil {
+			return nil, err
+		}
+		defer l.Close()
+		defer os.Remove(path)
+
+		// Set a timeout so the app doesn't hang forever if no one connects
+		l.(*net.UnixListener).SetDeadline(time.Now().Add(10 * time.Second))
+
+		conn, err := l.Accept()
+		if err != nil {
+			return nil, fmt.Errorf("timeout waiting for socket connection: %v", err)
+		}
+		defer conn.Close()
+
+		if mode == "read" {
+			return io.ReadAll(conn)
+		} else {
+			_, err = conn.Write(data)
+			return nil, err
+		}
+	}
+}
+
+func readSource(src string) ([]byte, error) {
+	if strings.HasPrefix(src, "http") {
+		resp, err := http.Get(src)
+		if err != nil {
+			return nil, err
+		}
+		defer resp.Body.Close()
+		return io.ReadAll(resp.Body)
+	}
+
+	if strings.HasSuffix(src, ".sock") {
+		return handleSocket(src, nil, "read")
+	}
+
+	return os.ReadFile(src)
+}
+
+func writeDestination(dest string, data []byte) error {
+	if strings.HasPrefix(dest, "http") {
+		resp, err := http.Post(dest, "application/json", bytes.NewBuffer(data))
+		if err != nil {
+			return err
+		}
+		defer resp.Body.Close()
+		return nil
+	}
+
+	if strings.HasSuffix(dest, ".sock") {
+		_, err := handleSocket(dest, data, "write")
+		return err
+	}
+
+	return os.WriteFile(dest, data, 0644)
+}
+
+func runPing(ip string) PingResult {
+	pinger, err := ping.NewPinger(ip)
+	res := PingResult{IP: ip, Timestamp: time.Now()}
+	if err != nil {
+		res.Error = err.Error()
+		return res
+	}
+
+	pinger.Count = 3
+	pinger.Timeout = time.Second * 5
+	// pinger.SetPrivileged(true) // Uncomment if running on Linux/Windows as admin
+
+	err = pinger.Run()
+	if err != nil {
+		res.Error = err.Error()
+		return res
+	}
+
+	stats := pinger.Statistics()
+	res.Sent = stats.PacketsSent
+	res.Received = stats.PacketsRecv
+	res.PacketLoss = stats.PacketLoss
+	res.AvgRtt = stats.AvgRtt
+	return res
+}
+
+func runTraceroute(ip string, maxHops int) *TracerouteResult {
+	result := &TracerouteResult{
+		Method: "icmp",
+		Hops:   []TracerouteHop{},
+	}
+
+	// Try ICMP traceroute first
+	if tr := tryICMPTraceroute(ip, maxHops); tr != nil {
+		return tr
+	}
+
+	// If ICMP fails, try TCP traceroute on common ports
+	if verbose {
+		log.Printf("ICMP traceroute failed for %s, trying TCP...", ip)
+	}
+
+	for _, port := range []int{80, 443, 22} {
+		if tr := tryTCPTraceroute(ip, port, maxHops); tr != nil {
+			tr.Method = fmt.Sprintf("tcp/%d", port)
+			return tr
+		}
+	}
+
+	result.Error = "traceroute failed (both ICMP and TCP)"
+	return result
+}
+
+func tryICMPTraceroute(ip string, maxHops int) *TracerouteResult {
+	var cmd *exec.Cmd
+
+	// Detect OS and use appropriate command
+	switch {
+	case fileExists("/usr/bin/traceroute"):
+		cmd = exec.Command("traceroute", "-m", strconv.Itoa(maxHops), "-n", "-q", "1", ip)
+	case fileExists("/usr/sbin/traceroute"):
+		cmd = exec.Command("traceroute", "-m", strconv.Itoa(maxHops), "-n", "-q", "1", ip)
+	case fileExists("/bin/traceroute"):
+		cmd = exec.Command("traceroute", "-m", strconv.Itoa(maxHops), "-n", "-q", "1", ip)
+	default:
+		// Try without full path
+		cmd = exec.Command("traceroute", "-m", strconv.Itoa(maxHops), "-n", "-q", "1", ip)
+	}
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return nil
+	}
+
+	return parseTracerouteOutput(string(output), "icmp")
+}
+
+func tryTCPTraceroute(ip string, port int, maxHops int) *TracerouteResult {
+	var cmd *exec.Cmd
+
+	// Try tcptraceroute if available
+	if fileExists("/usr/bin/tcptraceroute") || fileExists("/usr/sbin/tcptraceroute") {
+		cmd = exec.Command("tcptraceroute", "-m", strconv.Itoa(maxHops), "-n", "-q", "1", ip, strconv.Itoa(port))
+	} else {
+		// Try traceroute with TCP (-T flag on Linux)
+		cmd = exec.Command("traceroute", "-T", "-p", strconv.Itoa(port), "-m", strconv.Itoa(maxHops), "-n", "-q", "1", ip)
+	}
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return nil
+	}
+
+	return parseTracerouteOutput(string(output), fmt.Sprintf("tcp/%d", port))
+}
+
+func parseTracerouteOutput(output string, method string) *TracerouteResult {
+	result := &TracerouteResult{
+		Method: method,
+		Hops:   []TracerouteHop{},
+		Completed: false,
+	}
+
+	lines := strings.Split(output, "\n")
+
+	// Regex to match: " 1  192.168.1.1  1.234 ms"
+	hopRegex := regexp.MustCompile(`^\s*(\d+)\s+([0-9.]+)\s+([0-9.]+)\s*ms`)
+	// Regex to match timeouts: " 1  * * *"
+	timeoutRegex := regexp.MustCompile(`^\s*(\d+)\s+\*`)
+
+	for _, line := range lines {
+		if match := hopRegex.FindStringSubmatch(line); match != nil {
+			ttl, _ := strconv.Atoi(match[1])
+			hopIP := match[2]
+			rttMs, _ := strconv.ParseFloat(match[3], 64)
+			rtt := time.Duration(rttMs * float64(time.Millisecond))
+
+			result.Hops = append(result.Hops, TracerouteHop{
+				TTL: ttl,
+				IP:  hopIP,
+				Rtt: rtt,
+			})
+		} else if match := timeoutRegex.FindStringSubmatch(line); match != nil {
+			ttl, _ := strconv.Atoi(match[1])
+			result.Hops = append(result.Hops, TracerouteHop{
+				TTL:     ttl,
+				Timeout: true,
+			})
+		}
+	}
+
+	if len(result.Hops) > 0 {
+		result.Completed = true
+	}
+
+	return result
+}
+
+func fileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
+}