De-duplicate images in final discovery output

This change modifies DiscoveredImage to store the name/type of one
or more containers which use the image, and it also adds a new Insert
method on Manifest, which acts similarly to the built-in append
except duplicate entries are merged into the existing DiscoveredImage
instance in the list.

Signed-off-by: Caleb Xu <caxu@redhat.com>

Author: caxu-rh

discovery/discovery.go

@@ -1,17 +1,115 @@
 package discovery
 
+import (
+	"encoding/json"
+	"slices"
+)
+
 // Manifest represents the discovered components for a given application.
 type Manifest struct {
 	DiscoveredImages []DiscoveredImage
 }
 
-// DiscoveredImage is a container image that' been discovered based on the
-// workload watchers.
+func (m *Manifest) Equal(m1 Manifest) bool {
+	if len(m.DiscoveredImages) != len(m1.DiscoveredImages) {
+		return false
+	}
+	for idx := range m.DiscoveredImages {
+		if !m.DiscoveredImages[idx].Equal(m1.DiscoveredImages[idx]) {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Insert inserts images into the manifest. If an image is already present in
+// the manifest, the containers from the images to the inserted images are
+// inserted into the existing image in the manifest instead, avoiding the
+// creation of duplicate images in the manifest.
+func (m *Manifest) Insert(images ...DiscoveredImage) {
+	for _, image := range images {
+		idx := slices.IndexFunc(m.DiscoveredImages, func(i DiscoveredImage) bool {
+			return i.Image == image.Image
+		})
+
+		if idx == -1 {
+			m.DiscoveredImages = append(m.DiscoveredImages, image)
+		} else {
+			for _, container := range image.Containers {
+				containerExists := slices.ContainsFunc(m.DiscoveredImages[idx].Containers, func(c DiscoveredContainer) bool {
+					return c.Equal(container)
+				})
+
+				if !containerExists {
+					m.DiscoveredImages[idx].Containers = append(m.DiscoveredImages[idx].Containers, container)
+				}
+			}
+		}
+	}
+}
+
+// DiscoveredImage is a container image which was discovered in one or more workloads.
 type DiscoveredImage struct {
-	// PodName is the pod.metadata.name value where the image was discovered.
-	PodName string
-	// ContainerName represents the container in the pod that had the image.
-	ContainerName string
 	// Image is a fully qualified container image name and tag or digest.
 	Image string
+
+	// Containers is a list of DiscoveredContainer objects which are using
+	// the discovered image.
+	Containers []DiscoveredContainer
+}
+
+func (i *DiscoveredImage) Equal(i1 DiscoveredImage) bool {
+	return i.Image == i1.Image && slices.Equal(i.Containers, i1.Containers)
+}
+
+// DiscoveredContainer is a container which was observed during the discovery process.
+type DiscoveredContainer struct {
+	// Name is the name of a container in a pod.
+	Name string
+
+	// Type is the ContainerType of the container in its pod.
+	Type ContainerType
+
+	// Pod is the DiscoveredPod which this container is a part of.
+	Pod DiscoveredPod
+}
+
+func (c *DiscoveredContainer) Equal(c1 DiscoveredContainer) bool {
+	return c.Name == c1.Name && c.Type == c1.Type && c.Pod.Name == c1.Pod.Name && c.Pod.Namespace == c1.Pod.Namespace
+}
+
+// ContainerType is the type of a container in a pod.
+type ContainerType int
+
+const (
+	Container ContainerType = iota
+	InitContainer
+	EphemeralContainer
+)
+
+func (c ContainerType) String() string {
+	switch c {
+	case Container:
+		return "Container"
+	case InitContainer:
+		return "InitContainer"
+	case EphemeralContainer:
+		return "EphemeralContainer"
+	}
+
+	return ""
+}
+
+func (c ContainerType) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.String())
+}
+
+// DiscoveredPod is a pod that contains a discovered image.
+type DiscoveredPod struct {
+	// Name is the pod.metadata.name value where the image was discovered.
+	Name string
+
+	// Namespace is the pod.metadata.namespace value of the pod.
+	Namespace string
 }

internal/discover/processor.go

@@ -28,7 +28,7 @@ func NewManifestJSONProcessorFn(out io.Writer) ProcessingFunction {
 					continueRunning = false
 					break
 				}
-				m.DiscoveredImages = append(m.DiscoveredImages, processContainers(p, logger)...)
+				m.Insert(processContainers(p, logger)...)
 			case <-ctx.Done():
 				logger.Debug("processorFn completing because the context completed")
 				continueRunning = false
@@ -64,9 +64,17 @@ func processContainers(
 		found = append(
 			found,
 			discovery.DiscoveredImage{
-				PodName:       p.Name,
-				ContainerName: c.Name,
-				Image:         c.Image,
+				Image: c.Image,
+				Containers: []discovery.DiscoveredContainer{
+					{
+						Name: c.Name,
+						Type: discovery.Container,
+						Pod: discovery.DiscoveredPod{
+							Name:      p.Name,
+							Namespace: p.Namespace,
+						},
+					},
+				},
 			},
 		)
 	}
@@ -76,9 +84,17 @@ func processContainers(
 		found = append(
 			found,
 			discovery.DiscoveredImage{
-				PodName:       p.Name,
-				ContainerName: c.Name,
-				Image:         c.Image,
+				Image: c.Image,
+				Containers: []discovery.DiscoveredContainer{
+					{
+						Name: c.Name,
+						Type: discovery.InitContainer,
+						Pod: discovery.DiscoveredPod{
+							Name:      p.Name,
+							Namespace: p.Namespace,
+						},
+					},
+				},
 			},
 		)
 	}
@@ -88,9 +104,17 @@ func processContainers(
 		found = append(
 			found,
 			discovery.DiscoveredImage{
-				PodName:       p.Name,
-				ContainerName: c.Name,
-				Image:         c.Image,
+				Image: c.Image,
+				Containers: []discovery.DiscoveredContainer{
+					{
+						Name: c.Name,
+						Type: discovery.EphemeralContainer,
+						Pod: discovery.DiscoveredPod{
+							Name:      p.Name,
+							Namespace: p.Namespace,
+						},
+					},
+				},
 			},
 		)
 	}