package main
import (
"encoding/csv"
"encoding/json"
"flag"
"fmt"
"log"
"os"
"os/exec"
"regexp"
"strings"
)
// Globale Map zur Speicherung der IP-Anonymisierungen und der nächste Zähler
var ipMap = make(map[string]string)
var nextAnonID = 0
// Struktur für Disk-Device-Daten
type Disk struct {
Path string
Pool string
Source string
}
// Struktur für Container-Daten
type Container struct {
Name string
IP string
Profile string
Proxies []Proxy
Disks []Disk
}
// Struktur für Proxy-Device-Daten
type Proxy struct {
Name string
Listen string
Connect string
}
// Struktur für Netzwerk-Daten
type Network struct {
Name string
IP string
ACLs []string
ACLRules map[string]string
UsedBy []string
Forwards []string
}
func main() {
outFile := flag.String("out", "", "Pfad für die generierte HTML-Datei (Pflichtfeld)")
flag.Parse()
if *outFile == "" {
log.Fatal("Fehler: Bitte das -out Flag angeben")
}
containers, err := getLXCContainers()
if err != nil {
log.Fatalf("Fehler beim Auslesen der LXC Container: %v", err)
}
networks, err := getLXDNetworks()
if err != nil {
log.Fatalf("Fehler beim Auslesen der LXD Netzwerke: %v", err)
}
collectAllIPs(containers, networks)
// Konvertiere die Go-Map in ein JavaScript/JSON-Objekt
jsMap, err := json.Marshal(ipMap)
if err != nil {
log.Fatalf("Fehler beim Erstellen der JSON-Map: %v", err)
}
jsMapString := string(jsMap)
// 1. Map: Container-Namen auf das verbundene Netzwerk-Objekt abbilden.
containerNetworkMap := make(map[string]Network)
for _, n := range networks {
for _, cNamePath := range n.UsedBy {
// Pfad-Struktur: /1.0/instances/container-name
parts := strings.Split(cNamePath, "/")
if len(parts) >= 4 {
containerName := parts[3]
if _, exists := containerNetworkMap[containerName]; !exists {
containerNetworkMap[containerName] = n
}
}
}
}
// NEU: Map zur Speicherung eindeutiger Storage Blocks und ihrer Mermaid-ID
// Schlüssel: "Pool|Source"
storageBlocks := make(map[string]string)
nextStorageID := 0
// NEU: Alle eindeutigen Storage-Blöcke sammeln und IDs zuweisen
for _, c := range containers {
for _, disk := range c.Disks {
// Ein Storage Block ist eindeutig durch Pool und Source definiert
key := fmt.Sprintf("%s|%s", disk.Pool, disk.Source)
if _, exists := storageBlocks[key]; !exists {
// Erstellt eine eindeutige Mermaid-ID
storageID := fmt.Sprintf("Storage_Block_%d", nextStorageID)
storageBlocks[key] = storageID
nextStorageID++
}
}
}
var html strings.Builder
html.WriteString(fmt.Sprintf(`
LXD Mermaid Übersicht
IPs anonymisieren
Screenshot erstellen
graph LR
`, jsMapString))
// Netzwerke & ACLs (Rendering)
for _, n := range networks {
if len(n.UsedBy) == 0 && len(n.Forwards) == 0 {
continue
}
netID := strings.ReplaceAll(n.Name, "-", "_")
html.WriteString(fmt.Sprintf("%s[\"%s
`)
if err := os.WriteFile(*outFile, []byte(html.String()), 0644); err != nil {
log.Fatalf("Fehler beim Schreiben der Datei: %v", err)
}
fmt.Printf("Mermaid Diagramm erfolgreich generiert: %s\n", *outFile)
}
// getAndAnonymizeIP gibt die anonymisierte ID für eine IP zurück (oder generiert eine neue)
func getAndAnonymizeIP(ip string) string {
ip = strings.Split(ip, "/")[0] // Entferne CIDR-Suffix
// Ignoriere leere Strings
if ip == "" {
return ip
}
if anonID, exists := ipMap[ip]; exists {
return anonID
}
base := 65 // ASCII-Wert für 'A'
numLetters := 26 // A-Z
// Wir behandeln nextAnonID als eine Zahl im Basis-26-System.
// Die Stellen sind die vier Teile der Fake-IP-Adresse.
n := nextAnonID
// Teil 4 (letzte Stelle, am schnellsten steigend)
// Beispiel: 0 -> A, 1 -> B, ..., 26 -> A (mit Übertrag)
char4Index := n % numLetters
char4 := string(rune(base + char4Index))
n /= numLetters // Übertrag
// Teil 3
char3Index := n % numLetters
char3 := string(rune(base + char3Index))
n /= numLetters // Übertrag
// Teil 2
char2Index := n % numLetters
char2 := string(rune(base + char2Index))
n /= numLetters // Übertrag
// Teil 1 (steigt am langsamsten)
// Wenn n > 25, würden wir den 5. Teil benötigen. Wir begrenzen den Zähler n
// effektiv auf das, was in die 4 Stellen passt, aber da n bei jedem Aufruf
// wächst, wird die Zählung korrekt fortgesetzt.
char1Index := n % numLetters
char1 := string(rune(base + char1Index))
// Konstruiere die Fake-IP: A.A.A.A
anonID := fmt.Sprintf("%s.%s.%s.%s", char1, char2, char3, char4)
nextAnonID++
ipMap[ip] = anonID
return anonID
}
// collectAllIPs sammelt alle IPs, bevor das Rendering beginnt, um eine vollständige ipMap zu gewährleisten
func collectAllIPs(containers []Container, networks []Network) {
// Suchmuster für IPs mit optionaler CIDR-Maske
ipCIDRPattern := regexp.MustCompile(`\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}(/\d{1,2})?`)
// 1. Container IPs
for _, c := range containers {
//ip := strings.Split(c.IP, "/")[0]
//getAndAnonymizeIP(ip)
cleanedIPString := strings.ReplaceAll(c.IP, "