sultan/pkg/agent/workloads.go

package agent

import (
	"fmt"
	"maps"
	"net"
	"regexp"
	"slices"
	"strconv"
	"strings"

	"sultan/pkg/docker"
	"sultan/pkg/registry"
)

const servicesPrefix = "traefik.http.services."

var unsafeName = regexp.MustCompile(`[^A-Za-z0-9_-]`)

// Workloads übersetzt laufende Container in Workloads für service_state.
//
// Berücksichtigt werden nur Container mit traefik.enable=true. Weil der
// Ingress auf einem anderen Host sitzt, wird loadbalancer.server.port (Port
// im Container) auf den veröffentlichten Host-Port umgerechnet. Fehlt das
// Port-Label, gilt wie bei Traefiks Docker-Provider der einzige
// veröffentlichte Port; ohne Service-Labels entsteht ein Service mit dem
// Containernamen. Container, deren Ports von außen nicht erreichbar sind
// (nicht veröffentlicht, nur Loopback, nur UDP), werden mit Warnung
// weggelassen.
func Workloads(containers []docker.Container, host string) ([]registry.Workload, []string) {
	var out []registry.Workload
	var warnings []string
	for _, c := range containers {
		if !enabled(c.Labels) {
			continue
		}
		labels, warning := translatePorts(c)
		if warning != "" {
			warnings = append(warnings, warning)
			continue
		}
		out = append(out, registry.Workload{Name: c.Name(), Host: host, Labels: labels})
	}
	slices.SortFunc(out, func(a, b registry.Workload) int { return strings.Compare(a.Name, b.Name) })
	return out, warnings
}

func enabled(labels map[string]string) bool {
	for k, v := range labels {
		if strings.EqualFold(k, "traefik.enable") {
			on, err := strconv.ParseBool(strings.TrimSpace(v))
			return err == nil && on
		}
	}
	return false
}

// reachablePorts: Container-Port → von außen erreichbarer Host-Port (TCP).
func reachablePorts(ports []docker.Port) map[uint16]uint16 {
	out := map[uint16]uint16{}
	for _, p := range ports {
		if p.Type != "tcp" || p.PublicPort == 0 {
			continue
		}
		if ip := net.ParseIP(p.IP); ip != nil && ip.IsLoopback() {
			continue
		}
		out[p.PrivatePort] = p.PublicPort
	}
	return out
}

type serviceLabels struct {
	name    string // Schreibweise aus dem Label
	portKey string // Original-Schlüssel des Port-Labels, "" wenn keins
}

func translatePorts(c docker.Container) (map[string]string, string) {
	labels := maps.Clone(c.Labels)
	reachable := reachablePorts(c.Ports)
	single := func() (uint16, bool) {
		for _, pub := range reachable {
			return pub, len(reachable) == 1
		}
		return 0, false
	}

	services := map[string]*serviceLabels{}
	hasRouters := false
	for k := range labels {
		lk := strings.ToLower(k)
		if strings.HasPrefix(lk, "traefik.http.routers.") {
			hasRouters = true
		}
		rest, ok := strings.CutPrefix(lk, servicesPrefix)
		if !ok {
			continue
		}
		svc, attr, ok := strings.Cut(rest, ".")
		if !ok {
			continue
		}
		s := services[svc]
		if s == nil {
			name, _, _ := strings.Cut(k[len(servicesPrefix):], ".")
			s = &serviceLabels{name: name}
			services[svc] = s
		}
		if attr == "loadbalancer.server.port" {
			s.portKey = k
		}
	}

	if len(services) == 0 {
		if !hasRouters {
			return labels, ""
		}
		pub, ok := single()
		if !ok {
			return nil, fmt.Sprintf("Container %s: %d erreichbare Ports – Label loadbalancer.server.port angeben", c.Name(), len(reachable))
		}
		svc := unsafeName.ReplaceAllString(c.Name(), "-")
		labels[servicesPrefix+svc+".loadbalancer.server.port"] = strconv.Itoa(int(pub))
		return labels, ""
	}

	for _, s := range services {
		if s.portKey == "" {
			pub, ok := single()
			if !ok {
				return nil, fmt.Sprintf("Container %s, Service %s: %d erreichbare Ports – Label loadbalancer.server.port angeben", c.Name(), s.name, len(reachable))
			}
			labels[servicesPrefix+s.name+".loadbalancer.server.port"] = strconv.Itoa(int(pub))
			continue
		}
		private, err := strconv.Atoi(strings.TrimSpace(labels[s.portKey]))
		if err != nil {
			return nil, fmt.Sprintf("Container %s: Port %q nicht lesbar", c.Name(), labels[s.portKey])
		}
		pub, ok := reachable[uint16(private)]
		if !ok {
			return nil, fmt.Sprintf("Container %s: Port %d ist von außen nicht erreichbar (nicht veröffentlicht oder nur 127.0.0.1)", c.Name(), private)
		}
		labels[s.portKey] = strconv.Itoa(int(pub))
	}
	return labels, ""
}