Merge pull request #10 from PatchMon/feature/websock

Adding Docker networks and volumes

Author: 9technologygroup

cmd/patchmon-agent/commands/report.go

@@ -278,7 +278,13 @@ func sendDockerData(httpClient *client.Client, integrationData *models.Integrati
 		AgentVersion: version.Version,
 	}
 
-	logger.Info("Sending Docker data to server...")
+	logger.WithFields(logrus.Fields{
+		"containers": len(dockerData.Containers),
+		"images":     len(dockerData.Images),
+		"volumes":    len(dockerData.Volumes),
+		"networks":   len(dockerData.Networks),
+		"updates":    len(dockerData.Updates),
+	}).Info("Sending Docker data to server...")
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
@@ -291,6 +297,8 @@ func sendDockerData(httpClient *client.Client, integrationData *models.Integrati
 	logger.WithFields(logrus.Fields{
 		"containers": response.ContainersReceived,
 		"images":     response.ImagesReceived,
+		"volumes":    response.VolumesReceived,
+		"networks":   response.NetworksReceived,
 		"updates":    response.UpdatesFound,
 	}).Info("Docker data sent successfully")
 }

internal/integrations/docker/docker.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 	"sync"
 	"time"
 
@@ -103,6 +104,8 @@ func (d *Integration) Collect(ctx context.Context) (*models.IntegrationData, err
 	dockerData := &models.DockerData{
 		Containers: make([]models.DockerContainer, 0),
 		Images:     make([]models.DockerImage, 0),
+		Volumes:    make([]models.DockerVolume, 0),
+		Networks:   make([]models.DockerNetwork, 0),
 		Updates:    make([]models.DockerImageUpdate, 0),
 	}
 
@@ -124,6 +127,24 @@ func (d *Integration) Collect(ctx context.Context) (*models.IntegrationData, err
 		d.logger.WithField("count", len(images)).Info("Collected images")
 	}
 
+	// Collect volumes
+	volumes, err := d.collectVolumes(ctx)
+	if err != nil {
+		d.logger.WithError(err).Warn("Failed to collect volumes")
+	} else {
+		dockerData.Volumes = volumes
+		d.logger.WithField("count", len(volumes)).Info("Collected volumes")
+	}
+
+	// Collect networks
+	networks, err := d.collectNetworks(ctx)
+	if err != nil {
+		d.logger.WithError(err).Warn("Failed to collect networks")
+	} else {
+		dockerData.Networks = networks
+		d.logger.WithField("count", len(networks)).Info("Collected networks")
+	}
+
 	// Collect daemon info
 	daemonInfo, err := d.collectDaemonInfo(ctx)
 	if err != nil {
@@ -213,32 +234,47 @@ func determineImageSource(imageName string) string {
 		return "unknown"
 	}
 
-	// Check for common registries
-	if len(imageName) > 9 && imageName[:9] == "ghcr.io/" {
-		return "github"
+	// Extract domain from image name
+	parts := strings.SplitN(imageName, "/", 2)
+	if len(parts) == 1 {
+		// No domain specified, it's Docker Hub (implicit docker.io)
+		return "docker-hub"
 	}
-	if len(imageName) > 20 && imageName[:20] == "registry.gitlab.com/" {
-		return "gitlab"
+
+	domain := parts[0]
+
+	// Check if first part contains a dot or colon (indicates it's a domain)
+	if !strings.Contains(domain, ".") && !strings.Contains(domain, ":") {
+		// It's a Docker Hub image with org/repo format (e.g., "library/nginx")
+		return "docker-hub"
 	}
-	if len(imageName) > 4 && imageName[:4] == "gcr." {
+
+	// Match known registry domains (inspired by diun)
+	switch {
+	case domain == "docker.io":
+		return "docker-hub"
+	case domain == "ghcr.io":
+		return "github"
+	case domain == "docker.pkg.github.com":
+		return "github"
+	case domain == "registry.gitlab.com":
+		return "gitlab"
+	case strings.HasPrefix(domain, "gcr.io"):
 		return "google"
-	}
-	if len(imageName) > 4 && imageName[:4] == "quay" {
+	case strings.Contains(domain, "pkg.dev"): // Google Artifact Registry
+		return "google"
+	case domain == "quay.io":
 		return "quay"
-	}
-
-	// Count slashes to determine if it's a private registry
-	slashCount := 0
-	for _, ch := range imageName {
-		if ch == '/' {
-			slashCount++
-		}
-	}
-	if slashCount >= 2 {
+	case domain == "registry.access.redhat.com":
+		return "redhat"
+	case strings.Contains(domain, "azurecr.io"):
+		return "azure"
+	case strings.Contains(domain, "amazonaws.com"): // ECR
+		return "aws"
+	default:
+		// Private registry
 		return "private"
 	}
-
-	return "docker-hub"
 }
 
 // parseImageName parses image name into repository and tag

internal/integrations/docker/images.go

@@ -39,10 +39,7 @@ func (d *Integration) collectImages(ctx context.Context) ([]models.DockerImage,
 			// Parse image name
 			repository, tag := parseImageName(repoTag)
 
-			// Determine source
-			source := determineImageSource(repository)
-
-			// Get digest
+			// Get digest first to determine if image is locally built
 			digest := ""
 			if len(img.RepoDigests) > 0 {
 				// Extract just the hash part
@@ -52,6 +49,13 @@ func (d *Integration) collectImages(ctx context.Context) ([]models.DockerImage,
 				}
 			}
 
+			// Determine source - if no digest, image is locally built
+			source := determineImageSource(repository)
+			if len(img.RepoDigests) == 0 || digest == "" {
+				// No RepoDigests means the image was built locally and never pushed to a registry
+				source = "local"
+			}
+
 			// Convert created timestamp
 			var createdAt *time.Time
 			if img.Created > 0 {

internal/integrations/docker/networks.go

@@ -0,0 +1,78 @@
+package docker
+
+import (
+	"context"
+	"fmt"
+
+	"patchmon-agent/pkg/models"
+
+	"github.com/docker/docker/api/types/network"
+)
+
+// collectNetworks collects all Docker networks
+func (d *Integration) collectNetworks(ctx context.Context) ([]models.DockerNetwork, error) {
+	// List all networks
+	networks, err := d.client.NetworkList(ctx, network.ListOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to list networks: %w", err)
+	}
+
+	result := make([]models.DockerNetwork, 0, len(networks))
+
+	for _, net := range networks {
+		// Parse IPAM configuration
+		var ipam *models.DockerIPAM
+		// Check if IPAM config exists (Config slice length > 0 or Driver is set)
+		if len(net.IPAM.Config) > 0 || net.IPAM.Driver != "" {
+			ipam = &models.DockerIPAM{
+				Driver:  net.IPAM.Driver,
+				Options: net.IPAM.Options,
+				Config:  make([]models.DockerIPAMConfig, 0),
+			}
+
+			for _, ipamConfig := range net.IPAM.Config {
+				// Convert auxiliary addresses to map
+				auxAddresses := make(map[string]string)
+				if ipamConfig.AuxAddress != nil {
+					for k, v := range ipamConfig.AuxAddress {
+						auxAddresses[k] = v
+					}
+				}
+
+				ipamConfigData := models.DockerIPAMConfig{
+					Subnet:       ipamConfig.Subnet,
+					Gateway:      ipamConfig.Gateway,
+					IPRange:      ipamConfig.IPRange,
+					AuxAddresses: auxAddresses,
+				}
+				ipam.Config = append(ipam.Config, ipamConfigData)
+			}
+		}
+
+		// Count containers attached to this network
+		containerCount := len(net.Containers)
+
+		networkData := models.DockerNetwork{
+			NetworkID:      net.ID,
+			Name:           net.Name,
+			Driver:         net.Driver,
+			Scope:          net.Scope,
+			IPv6Enabled:    net.EnableIPv6,
+			Internal:       net.Internal,
+			Attachable:     net.Attachable,
+			Ingress:        net.Ingress,
+			ConfigOnly:     net.ConfigOnly,
+			Labels:         net.Labels,
+			IPAM:           ipam,
+			ContainerCount: containerCount,
+		}
+
+		// Note: Docker networks don't have a CreatedAt timestamp in the List response
+		// We'd need to inspect each network individually to get it, which is expensive
+		// So we'll leave CreatedAt as nil for now
+
+		result = append(result, networkData)
+	}
+
+	return result, nil
+}

internal/integrations/docker/volumes.go

@@ -0,0 +1,87 @@
+package docker
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"patchmon-agent/pkg/models"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/volume"
+)
+
+// collectVolumes collects all Docker volumes
+func (d *Integration) collectVolumes(ctx context.Context) ([]models.DockerVolume, error) {
+	// List all volumes
+	volumes, err := d.client.VolumeList(ctx, volume.ListOptions{})
+	if err != nil {
+		return nil, fmt.Errorf("failed to list volumes: %w", err)
+	}
+
+	result := make([]models.DockerVolume, 0, len(volumes.Volumes))
+
+	// Get system disk usage info to include volume sizes
+	diskUsage, err := d.client.DiskUsage(ctx, types.DiskUsageOptions{})
+	if err != nil {
+		d.logger.WithError(err).Debug("Failed to get disk usage (volume sizes unavailable)")
+	}
+
+	// Create a map of volume name to usage for quick lookup
+	volumeUsage := make(map[string]int64)
+	if err == nil {
+		for _, vol := range diskUsage.Volumes {
+			if vol.UsageData != nil {
+				volumeUsage[vol.Name] = vol.UsageData.Size
+			}
+		}
+	}
+
+	for _, vol := range volumes.Volumes {
+		// Parse created timestamp
+		var createdAt *time.Time
+		if vol.CreatedAt != "" {
+			// Docker returns RFC3339Nano format
+			if t, err := time.Parse(time.RFC3339Nano, vol.CreatedAt); err == nil {
+				createdAt = &t
+			}
+		}
+
+		// Get volume size if available
+		var sizeBytes *int64
+		if size, found := volumeUsage[vol.Name]; found {
+			sizeBytes = &size
+		}
+
+		// Get driver renderer if available (e.g., "overlay2" for overlay2 driver)
+		renderer := ""
+		if vol.Options != nil {
+			if t, ok := vol.Options["type"]; ok {
+				renderer = t
+			}
+		}
+
+		volumeData := models.DockerVolume{
+			VolumeID:   vol.Name, // Docker volumes are identified by name
+			Name:       vol.Name,
+			Driver:     vol.Driver,
+			Mountpoint: vol.Mountpoint,
+			Renderer:   renderer,
+			Scope:      vol.Scope,
+			Labels:     vol.Labels,
+			Options:    vol.Options,
+			CreatedAt:  createdAt,
+			SizeBytes:  sizeBytes,
+			RefCount:   0, // Will be set below if available
+		}
+
+		// Get reference count from usage data if available
+		if vol.UsageData != nil && vol.UsageData.RefCount >= 0 {
+			volumeData.RefCount = int(vol.UsageData.RefCount)
+		}
+
+		result = append(result, volumeData)
+	}
+
+	return result, nil
+}

internal/version/version.go

@@ -1,4 +1,4 @@
 package version
 
 // Version represents the current version of the patchmon-agent
-const Version = "1.3.1"
+const Version = "1.3.2"