remove go func

go/main.go

@@ -20,9 +20,12 @@ import (
 )
 
 type ImageStatus struct {
-    ContainerName, Image, Tag string
+	ContainerName    string
+	Image            string
+	Tag              string
 	UpdateAvailable  float64
-    LocalDigest, RemoteDigest string
+	LocalDigest      string
+	RemoteDigest     string
 }
 
 type StatusCache struct {
@@ -71,20 +74,23 @@ func checkImageUpdates() {
 		return
 	}
 	defer cli.Close()
+
 	rc := regclient.New()
 
+	// Nur laufende Container abrufen
 	containers, err := cli.ContainerList(ctx, container.ListOptions{All: false})
 	if err != nil {
-        log.Printf("Fehler bei ContainerList: %v", err)
+		log.Printf("Fehler beim ContainerList: %v", err)
 		return
 	}
 
 	images, err := cli.ImageList(ctx, image.ListOptions{All: true})
 	if err != nil {
-        log.Printf("Fehler bei ImageList: %v", err)
+		log.Printf("Fehler beim ImageList: %v", err)
 		return
 	}
 
+	// RepoTag → Digest map
 	imageTagToDigest := make(map[string]string)
 	for _, img := range images {
 		for _, tag := range img.RepoTags {
@@ -96,59 +102,61 @@ func checkImageUpdates() {
 		}
 	}
 
-    var wg sync.WaitGroup
 	results := make([]ImageStatus, 0)
-    resultsLock := sync.Mutex{}
 	for _, ctr := range containers {
 		tag := ctr.Image
-        imageRef, err := toRegistryImage(tag)
-        if err != nil {
-            log.Printf("ImageRef-Fehler bei %s: %v", tag, err)
-            continue
-        }
-        localDigest := imageTagToDigest[tag]
 		containerName := "unknown"
 		if len(ctr.Names) > 0 {
 			containerName = ctr.Names[0]
 		}
-        wg.Add(1)
+
-        go func(containerName, tag, localDigest, imageRef string) {
+		imageRef, err := toRegistryImage(tag)
-            defer wg.Done()
+		if err != nil {
+			log.Printf("Fehler beim Parsen des Image-Namens (%s): %v", tag, err)
+			continue
+		}
+
+		localDigest := imageTagToDigest[tag]
+
 		refObj, err := ref.New(imageRef)
 		if err != nil {
-                log.Printf("ImageRef (regclient) ungültig (%s): %v", tag, err)
+			log.Printf("Ungültige Image-Referenz (%s): %v", tag, err)
-                return
+			continue
 		}
+
 		desc, err := rc.ManifestHead(ctx, refObj)
 		if err != nil {
-                log.Printf("Remote-Manifest nicht gefunden (%s): %v", tag, err)
+			log.Printf("Fehler beim Abrufen des Remote-Manifests (%s): %v", tag, err)
-                return
+			continue
 		}
 		remoteDigest := desc.GetDigest().String()
 
 		update := 0.0
 		if localDigest != remoteDigest {
 			update = 1.0
-                fmt.Printf("Container: %s\n  Image: %s\n  Local Digest:  %s\n  Remote Digest: %s\n  -> Update verfügbar!\n", containerName, tag, localDigest, remoteDigest)
+			fmt.Printf("Container: %s\n  Image: %s\n  Local Digest:  %s\n  Remote Digest: %s\n  -> Update verfügbar!\n",
+				containerName, tag, localDigest, remoteDigest)
 		} else {
-                fmt.Printf("Container: %s\n  Image: %s\n  Local Digest:  %s\n  Remote Digest: %s\n  -> Kein Update verfügbar.\n", containerName, tag, localDigest, remoteDigest)
+			fmt.Printf("Container: %s\n  Image: %s\n  Local Digest:  %s\n  Remote Digest: %s\n  -> Kein Update verfügbar.\n",
+				containerName, tag, localDigest, remoteDigest)
 		}
 
 		labelImg, labelTag := tag, "latest"
 		if cp := strings.Split(tag, ":"); len(cp) == 2 {
 			labelImg, labelTag = cp[0], cp[1]
 		}
-            resultsLock.Lock()
-            results = append(results, ImageStatus{
-                ContainerName: containerName, Image: labelImg, Tag: labelTag,
-                UpdateAvailable: update, LocalDigest: localDigest, RemoteDigest: remoteDigest,
-            })
-            resultsLock.Unlock()
-        }(containerName, tag, localDigest, imageRef)
-    }
-    wg.Wait()
 
-    // Im Cache speichern
+		results = append(results, ImageStatus{
+			ContainerName:   containerName,
+			Image:           labelImg,
+			Tag:             labelTag,
+			UpdateAvailable: update,
+			LocalDigest:     localDigest,
+			RemoteDigest:    remoteDigest,
+		})
+	}
+
+	// Speichern in Cache
 	cache.Lock()
 	cache.Data = results
 	cache.LastCheck = time.Now()
@@ -163,7 +171,7 @@ func newImageUpdateCollector() *imageUpdateCollector {
 	return &imageUpdateCollector{
 		metric: prometheus.NewDesc(
 			"docker_image_update_available",
-            "Ob Update für das lokale Docker-Image des laufenden Containers für das Tag im Registry verfügbar ist (1=Update, 0=aktuell)",
+			"Ob Update für das lokale Docker-Image eines laufenden Containers verfügbar ist (1 = Update, 0 = aktuell)",
 			[]string{"container_name", "image", "tag"},
 			nil,
 		),
@@ -176,29 +184,30 @@ func (c *imageUpdateCollector) Describe(ch chan<- *prometheus.Desc) {
 
 func (c *imageUpdateCollector) Collect(ch chan<- prometheus.Metric) {
 	cache.RLock()
+	defer cache.RUnlock()
 	for _, stat := range cache.Data {
 		ch <- prometheus.MustNewConstMetric(
 			c.metric, prometheus.GaugeValue,
 			stat.UpdateAvailable, stat.ContainerName, stat.Image, stat.Tag,
 		)
 	}
-    cache.RUnlock()
 }
 
 func main() {
-    log.Printf("Starte Docker-Image-Update-Exporter mit 6h-Intervall...")
+	log.Printf("🚀 Docker Image Update Exporter gestartet (Intervall = %v)", interval)
 
-    // Hintergrund: alle 6h Update, zu Beginn auch direkt
+	// Hintergrundprozess zum Aktualisieren des Caches
 	go func() {
 		for {
 			checkImageUpdates()
 			time.Sleep(interval)
 		}
 	}()
-    checkImageUpdates() // Initiales Scrape
+	checkImageUpdates() // initial
 
 	exporter := newImageUpdateCollector()
 	prometheus.MustRegister(exporter)
+
 	http.Handle("/metrics", promhttp.Handler())
 	log.Fatal(http.ListenAndServe(":9788", nil))
 }