coroot · def · Sep 29, 2025 · Sep 25, 2025
diff --git a/api/ctx.go b/api/ctx.go
@@ -18,6 +18,7 @@ type Context struct {
 	Status    Status                            `json:"status"`
 	Search    Search                            `json:"search"`
 	Incidents map[model.ApplicationCategory]int `json:"incidents"`
+	Fluxcd    bool                              `json:"fluxcd"`
 	License   *License                          `json:"license,omitempty"`
 }
 
@@ -76,6 +77,7 @@ func (api *Api) WithContext(p *db.Project, cacheStatus *cache.Status, w *model.W
 			Status:    renderStatus(p, cacheStatus, w, api.globalPrometheus),
 			Search:    renderSearch(w),
 			Incidents: renderIncidents(w),
+			Fluxcd:    w != nil && w.Flux != nil,
 		},
 		Data: data,
 	}

diff --git a/api/views/overview/fluxcd.go b/api/views/overview/fluxcd.go
@@ -0,0 +1,162 @@
+package overview
+
+import (
+	"sort"
+
+	"github.com/coroot/coroot/model"
+	"golang.org/x/exp/maps"
+)
+
+type InventoryEntry struct {
+	ID          model.ApplicationId `json:"id"`
+	CorootAppId model.ApplicationId `json:"coroot_app_id"`
+}
+
+type FluxCDResource struct {
+	ID                    model.ApplicationId   `json:"id"`
+	Type                  string                `json:"type"`
+	Name                  string                `json:"name"`
+	Namespace             string                `json:"namespace"`
+	Status                string                `json:"status"`
+	Reason                string                `json:"reason"`
+	Suspended             bool                  `json:"suspended"`
+	URL                   string                `json:"url,omitempty"`
+	Interval              string                `json:"interval,omitempty"`
+	Chart                 string                `json:"chart,omitempty"`
+	Version               string                `json:"version,omitempty"`
+	TargetNamespace       string                `json:"target_namespace,omitempty"`
+	RepositoryId          model.ApplicationId   `json:"repository_id,omitempty"`
+	Dependencies          []model.ApplicationId `json:"dependencies,omitempty"`
+	InventoryEntries      []InventoryEntry      `json:"inventory_entries,omitempty"`
+	LastAppliedRevision   string                `json:"last_applied_revision"`
+	LastAttemptedRevision string                `json:"last_attempted_revision"`
+}
+
+func renderFluxCD(w *model.World) []*FluxCDResource {
+	if w == nil || w.Flux == nil {
+		return []*FluxCDResource{}
+	}
+	flux := w.Flux
+	var resources []*FluxCDResource
+
+	for id, repo := range flux.Repositories {
+		resources = append(resources, &FluxCDResource{
+			ID:        id,
+			Type:      string(id.Kind),
+			Name:      id.Name,
+			Namespace: id.Namespace,
+			Status:    getFluxResourceStatus(&repo.Ready, repo.Suspended),
+			Reason:    repo.Ready.Reason.Value(),
+			Suspended: repo.Suspended,
+			URL:       repo.Url.Value(),
+			Interval:  repo.Interval.Value(),
+		})
+	}
+
+	for id, chart := range flux.HelmCharts {
+		resources = append(resources, &FluxCDResource{
+			ID:           id,
+			Type:         string(id.Kind),
+			Name:         id.Name,
+			Namespace:    id.Namespace,
+			Status:       getFluxResourceStatus(&chart.Ready, chart.Suspended),
+			Reason:       chart.Ready.Reason.Value(),
+			Suspended:    chart.Suspended,
+			Chart:        chart.Chart,
+			Version:      chart.Version,
+			Interval:     chart.Interval,
+			RepositoryId: chart.RepositoryId,
+		})
+	}
+
+	for id, release := range flux.HelmReleases {
+		resources = append(resources, &FluxCDResource{
+			ID:              id,
+			Type:            string(id.Kind),
+			Name:            id.Name,
+			Namespace:       id.Namespace,
+			Status:          getFluxResourceStatus(&release.Ready, release.Suspended),
+			Reason:          release.Ready.Reason.Value(),
+			Suspended:       release.Suspended,
+			Chart:           release.Chart,
+			Version:         release.Version,
+			Interval:        release.Interval,
+			TargetNamespace: release.TargetNamespace,
+			RepositoryId:    release.RepositoryId,
+		})
+	}
+
+	for id, kustomization := range flux.Kustomizations {
+		dependencies := maps.Keys(kustomization.DependsOn)
+		sort.Slice(dependencies, func(i, j int) bool {
+			return dependencies[i].String() < dependencies[j].String()
+		})
+		resources = append(resources, &FluxCDResource{
+			ID:                    id,
+			Type:                  string(id.Kind),
+			Name:                  id.Name,
+			Namespace:             id.Namespace,
+			Status:                getFluxResourceStatus(&kustomization.Ready, kustomization.Suspended),
+			Reason:                kustomization.Ready.Reason.Value(),
+			Suspended:             kustomization.Suspended,
+			Interval:              kustomization.Interval,
+			TargetNamespace:       kustomization.TargetNamespace,
+			RepositoryId:          kustomization.RepositoryId,
+			Dependencies:          dependencies,
+			InventoryEntries:      getInventoryEntries(w, kustomization.InventoryEntries),
+			LastAppliedRevision:   kustomization.LastAppliedRevision,
+			LastAttemptedRevision: kustomization.LastAttemptedRevision,
+		})
+	}
+
+	for id, resourceSet := range flux.ResourceSets {
+		dependencies := maps.Keys(resourceSet.DependsOn)
+		sort.Slice(dependencies, func(i, j int) bool {
+			return dependencies[i].String() < dependencies[j].String()
+		})
+		resources = append(resources, &FluxCDResource{
+			ID:                  id,
+			Type:                string(id.Kind),
+			Name:                id.Name,
+			Namespace:           id.Namespace,
+			Status:              getFluxResourceStatus(&resourceSet.Ready, false),
+			Reason:              resourceSet.Ready.Reason.Value(),
+			Suspended:           false,
+			Dependencies:        dependencies,
+			InventoryEntries:    getInventoryEntries(w, resourceSet.InventoryEntries),
+			LastAppliedRevision: resourceSet.LastAppliedRevision.Value(),
+		})
+	}
+
+	return resources
+}
+
+func getInventoryEntries(w *model.World, src map[model.ApplicationId]bool) []InventoryEntry {
+	entries := make([]InventoryEntry, 0)
+	for eId := range src {
+		e := InventoryEntry{ID: eId}
+		if app := w.GetApplication(eId); app != nil {
+			e.CorootAppId = app.Id
+		}
+		entries = append(entries, e)
+	}
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].ID.String() < entries[j].ID.String()
+	})
+	return entries
+}
+
+func getFluxResourceStatus(ready *model.FluxStatus, suspended bool) string {
+	if suspended {
+		return "Suspended"
+	}
+
+	switch ready.Status {
+	case model.OK:
+		return "Ready"
+	case model.WARNING:
+		return "Failed"
+	default:
+		return "Unknown"
+	}
+}
diff --git a/api/views/overview/overview.go b/api/views/overview/overview.go
@@ -18,6 +18,7 @@ type Overview struct {
 	Logs         *Logs                       `json:"logs"`
 	Costs        *Costs                      `json:"costs"`
 	Risks        []*Risk                     `json:"risks"`
+	FluxCD       []*FluxCDResource           `json:"fluxcd"`
 	Categories   []model.ApplicationCategory `json:"categories"`
 }
 
@@ -47,6 +48,8 @@ func Render(ctx context.Context, ch *clickhouse.Client, project *db.Project, w *
 		v.Costs = renderCosts(w)
 	case "risks":
 		v.Risks = renderRisks(w)
+	case "fluxcd":
+		v.FluxCD = renderFluxCD(w)
 	}
 	return v
 }
diff --git a/constructor/constructor.go b/constructor/constructor.go
@@ -98,6 +98,7 @@ func (c *Constructor) LoadWorld(ctx context.Context, from, to timeseries.Time, s
 	prof.stage("load_fqdn", func() { loadFQDNs(metrics, ip2fqdn, fqdn2ip) })
 	prof.stage("load_fargate_nodes", func() { c.loadFargateNodes(metrics, nodes) })
 	prof.stage("load_k8s_metadata", func() { loadKubernetesMetadata(w, metrics, servicesByClusterIP) })
+	prof.stage("load_flux_resources", func() { loadFluxResources(w, metrics) })
 	prof.stage("load_aws_status", func() { loadAWSStatus(w, metrics) })
 	prof.stage("load_rds_metadata", func() { loadRdsMetadata(w, metrics, pjs, rdsInstancesById) })
 	prof.stage("load_elasticache_metadata", func() { loadElasticacheMetadata(w, metrics, pjs, ecInstancesById) })