utils.go hinzugefügt

client.go

@@ -0,0 +1,103 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+)
+
+type AdGuardClient struct {
+	BaseURL  string
+	Username string
+	Password string
+	Client   *http.Client
+}
+
+func NewAdGuardClient() (*AdGuardClient, error) {
+	baseURL := os.Getenv("ADGUARD_URL")
+	user := os.Getenv("ADGUARD_USER")
+	pass := os.Getenv("ADGUARD_PASSWORD")
+
+	if baseURL == "" || user == "" || pass == "" {
+		return nil, fmt.Errorf("fehlende Umgebungsvariablen")
+	}
+
+	return &AdGuardClient{
+		BaseURL:  baseURL,
+		Username: user,
+		Password: pass,
+		Client:   &http.Client{},
+	}, nil
+}
+
+func (c *AdGuardClient) Login() error {
+	data := map[string]string{"name": c.Username, "password": c.Password}
+	return c.post("/control/login", data, nil)
+}
+
+func (c *AdGuardClient) GetRewrites() ([]Rewrite, error) {
+	resp, err := c.Client.Get(c.BaseURL + "/control/rewrite/list")
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	var list []Rewrite
+	if err := json.NewDecoder(resp.Body).Decode(&list); err != nil {
+		return nil, err
+	}
+	return list, nil
+}
+
+func (c *AdGuardClient) AddRewrite(r Rewrite) error {
+	return c.post("/control/rewrite/add", r, nil)
+}
+
+func (c *AdGuardClient) DeleteRewrite(r Rewrite) error {
+	return c.post("/control/rewrite/delete", r, nil)
+}
+
+func (c *AdGuardClient) UpdateRewrite(oldR, newR Rewrite) error {
+	payload := map[string]Rewrite{"target": oldR, "update": newR}
+	return c.put("/control/rewrite/update", payload, nil)
+}
+
+func (c *AdGuardClient) post(path string, body any, result any) error {
+	return c.doRequest("POST", path, body, result)
+}
+
+func (c *AdGuardClient) put(path string, body any, result any) error {
+	return c.doRequest("PUT", path, body, result)
+}
+
+func (c *AdGuardClient) doRequest(method, path string, body any, result any) error {
+	b, err := json.Marshal(body)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest(method, c.BaseURL+path, bytes.NewReader(b))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := c.Client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("Fehler %d: %s", resp.StatusCode, string(body))
+	}
+
+	if result != nil {
+		return json.NewDecoder(resp.Body).Decode(result)
+	}
+	return nil
+}

main.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+func main() {
+	LoadEnv()
+
+	client, err := NewAdGuardClient()
+	if err != nil {
+		log.Fatalf("Fehler beim Initialisieren des Clients: %v", err)
+	}
+
+	if err := client.Login(); err != nil {
+		log.Fatalf("Login fehlgeschlagen: %v", err)
+	}
+	log.Println("Login erfolgreich.")
+
+	current, err := client.GetRewrites()
+	if err != nil {
+		log.Fatalf("Fehler beim Abrufen der Rewrites: %v", err)
+	}
+
+	desired, err := LoadYAML()
+	if err != nil {
+		log.Fatalf("Fehler beim Laden der YAML-Datei: %v", err)
+	}
+
+	merged := MergeRewrites(current, desired)
+
+	if err := SaveYAML(merged); err != nil {
+		log.Fatalf("Fehler beim Speichern der YAML-Datei: %v", err)
+	}
+
+	if err := client.ApplyRewrites(merged); err != nil {
+		log.Fatalf("Fehler beim Anwenden der Änderungen: %v", err)
+	}
+
+	log.Println("Alle Änderungen wurden erfolgreich angewendet.")
+}

rewrites.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"fmt"
+)
+
+type Rewrite struct {
+	Domain string `yaml:"domain" json:"domain"`
+	Answer string `yaml:"answer" json:"answer"`
+}
+
+func MergeRewrites(existing, desired []Rewrite) []Rewrite {
+	existingMap := make(map[string]string)
+	for _, r := range existing {
+		existingMap[r.Domain] = r.Answer
+	}
+
+	desiredMap := make(map[string]string)
+	for _, r := range desired {
+		desiredMap[r.Domain] = r.Answer
+	}
+
+	updated := make([]Rewrite, 0)
+
+	// Add or update
+	for domain, ip := range desiredMap {
+		if existingIP, found := existingMap[domain]; found {
+			if existingIP != ip {
+				fmt.Printf("Ändere %s: %s -> %s\n", domain, existingIP, ip)
+			}
+		} else {
+			fmt.Printf("Füge hinzu: %s -> %s\n", domain, ip)
+		}
+		updated = append(updated, Rewrite{Domain: domain, Answer: ip})
+	}
+
+	// Delete outdated
+	for domain, ip := range existingMap {
+		if _, ok := desiredMap[domain]; !ok {
+			fmt.Printf("Lösche: %s : %s\n", domain, ip)
+		}
+	}
+
+	return updated
+}
+
+func (c *AdGuardClient) ApplyRewrites(desired []Rewrite) error {
+	existing, err := c.GetRewrites()
+	if err != nil {
+		return err
+	}
+
+	existingMap := make(map[string]string)
+	for _, r := range existing {
+		existingMap[r.Domain] = r.Answer
+	}
+
+	desiredMap := make(map[string]string)
+	for _, r := range desired {
+		desiredMap[r.Domain] = r.Answer
+	}
+
+	for domain, ip := range desiredMap {
+		if existingIP, ok := existingMap[domain]; ok {
+			if existingIP != ip {
+				if err := c.UpdateRewrite(Rewrite{Domain: domain, Answer: existingIP}, Rewrite{Domain: domain, Answer: ip}); err != nil {
+					return err
+				}
+			}
+		} else {
+			if err := c.AddRewrite(Rewrite{Domain: domain, Answer: ip}); err != nil {
+				return err
+			}
+		}
+	}
+
+	for domain, ip := range existingMap {
+		if _, ok := desiredMap[domain]; !ok {
+			if err := c.DeleteRewrite(Rewrite{Domain: domain, Answer: ip}); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

utils.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/joho/godotenv"
+	"gopkg.in/yaml.v3"
+)
+
+func LoadEnv() {
+	if err := godotenv.Load(); err != nil {
+		fmt.Println("Warnung: .env Datei konnte nicht geladen werden.")
+	}
+}
+
+func LoadYAML() ([]Rewrite, error) {
+	file := os.Getenv("YAML_FILE")
+	f, err := os.Open(file)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	var data struct {
+		Rewrites []Rewrite `yaml:"rewrites"`
+	}
+	err = yaml.NewDecoder(f).Decode(&data)
+	return data.Rewrites, err
+}
+
+func SaveYAML(rewrites []Rewrite) error {
+	file := os.Getenv("YAML_FILE")
+	f, err := os.Create(file)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	data := map[string][]Rewrite{
+		"rewrites": rewrites,
+	}
+	enc := yaml.NewEncoder(f)
+	enc.SetIndent(2)
+	return enc.Encode(data)
+}